
developer-kit-aws
AWS infrastructure and CloudFormation expertise
- version
- 4.0.1
- GitHub stars
- 372
Install
/plugin install developer-kit-aws@developer-kitRun it inside Claude Code after adding the marketplace with /plugin marketplace add giuseppe-trisciuoglio/developer-kit.
Contents
Discovered from sourceSkills 19
AWS CloudFormation Auto Scaling
Overview
Create production-ready Auto Scaling infrastructure using AWS CloudFormation templates. This skill covers Auto Scaling Groups for EC2, ECS, and Lambda, launch configurations, launch templates, scaling policies, lifecycle hooks, and best practices for high availability and cost optimization.
When to Use
Use this skill when:
- Creating Auto Scaling Groups for EC2 instances
- Configuring Launch Configurations or Launch Templates
- Implementing scaling policies (step, target tracking, simple)
- Adding lifecycle hooks for lifecycle management
- Creating scaling for ECS services
- Implementing Lambda provisioned concurrency scaling
- Organizing templates with Parameters, Outputs, Mappings, Conditions
- Implementing cross-stack references with export/import
- Using mixed instances policies for diversity
Instructions
Follow these steps to create Auto Scaling infrastructure with CloudFormation:
1. Define Parameters
Specify capacity and instance settings with AWS-specific parameter types:
Parameters:
MinSize:
Type: Number
Default: 2
Description: Minimum number of instances
MaxSize:
Type: Number
Default: 10
Description: Maximum number of instances
DesiredCapacity:
Type: Number
Default: 2
Description: Desired number of instances
InstanceType:
Type: AWS::EC2::Instance::Type
Default: t3.micro
Description: EC2 instance type
AmiId:
Type: AWS::EC2::Image::Id
Description: AMI ID for instances
SubnetIds:
Type: List<AWS::EC2::Subnet::Id>
Description: Subnets for Auto Scaling group
2. Create Launch Configuration
Define instance launch settings:
Resources:
MyLaunchConfiguration:
Type: AWS::AutoScaling::LaunchConfiguration
Properties:
LaunchConfigurationName: !Sub "${AWS::StackName}-lc"
ImageId: !Ref AmiId
InstanceType: !Ref InstanceType
KeyName: !Ref KeyName
SecurityGroups:
- !Ref InstanceSecurityGroup
InstanceMonitoring: Enabled
UserData:
Fn::Base64: |
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
3. Create Auto Scaling Group
Specify min/max/desired capacity and networking:
Resources:
MyAutoScalingGroup:
Type: AWS::AutoScaling::AutoScalingGroup
Properties:
AutoScalingGroupName: !Sub "${AWS::StackName}-asg"
MinSize: !Ref MinSize
MaxSize: !Ref MaxSize
DesiredCapacity: !Ref DesiredCapacity
VPCZoneIdentifier: !Ref SubnetIds
LaunchConfigurationName: !Ref MyLaunchConfiguration
TargetGroupARNs:
- !Ref MyTargetGroup
HealthCheckType: ELB
HealthCheckGracePeriod: 300
Tags:
- Key: Environment
Value: !Ref Environment
PropagateAtLaunch: true
4. Configure Load Balancer Integration
Set up ALB for traffic distribution:
Resources:
MyTargetGroup:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
Name: !Sub "${AWS::StackName}-tg"
Port: 80
Protocol: HTTP
VpcId: !Ref VPCId
HealthCheckPath: /
TargetType: instance
MyLoadBalancer:
Type: AWS::ElasticLoadBalancingV2::LoadBalancer
Properties:
Name: !Sub "${AWS::StackName}-alb"
Scheme: internet-facing
Type: application
Subnets:
- !Ref PublicSubnet1
- !Ref PublicSubnet2
5. Add Scaling Policies
Implement target tracking scaling:
Resources:
TargetTrackingPolicy:
Type: AWS::AutoScaling::ScalingPolicy
Properties:
PolicyName: !Sub "${AWS::StackName}-target-tracking"
PolicyType: TargetTrackingScaling
AutoScalingGroupName: !Ref MyAutoScalingGroup
TargetTrackingConfiguration:
PredefinedMetricSpecification:
PredefinedMetricType: ASGAverageCPUUtilization
TargetValue: 70
DisableScaleIn: false
6. Configure Lifecycle Hooks
Implement hooks for graceful instance management:
Resources:
LifecycleHookTermination:
Type: AWS::AutoScaling::LifecycleHook
Properties:
LifecycleHookName: !Sub "${AWS::StackName}-termination-hook"
AutoScalingGroupName: !Ref MyAutoScalingGroup
LifecycleTransition: autoscaling:EC2_INSTANCE_TERMINATING
HeartbeatTimeout: 300
NotificationTargetARN: !Ref SNSTopic
RoleARN: !Ref LifecycleHookRole
7. Set Up Monitoring
Configure CloudWatch alarms for scaling triggers:
Resources:
HighCpuAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: !Sub "${AWS::StackName}-high-cpu"
MetricName: CPUUtilization
Namespace: AWS/EC2
Dimensions:
- Name: AutoScalingGroupName
Value: !Ref MyAutoScalingGroup
Statistic: Average
Period: 60
EvaluationPeriods: 3
Threshold: 70
ComparisonOperator: GreaterThanThreshold
8. Configure Outputs and Cross-Stack References
Export ASG configuration for other stacks:
Outputs:
AutoScalingGroupName:
Description: Name of the Auto Scaling Group
Value: !Ref MyAutoScalingGroup
Export:
Name: !Sub "${AWS::StackName}-AutoScalingGroupName"
AutoScalingGroupArn:
Description: ARN of the Auto Scaling Group
Value: !GetAtt MyAutoScalingGroup.AutoScalingGroupArn
Export:
Name: !Sub "${AWS::StackName}-AutoScalingGroupArn"
Examples
Complete Auto Scaling Template
Full end-to-end template with VPC, ASG, ALB, and scaling policies:
AWSTemplateFormatVersion: '2010-09-09'
Description: Auto Scaling Group with ALB integration
Parameters:
Environment:
Type: String
Default: production
InstanceType:
Type: AWS::EC2::Instance::Type
Default: t3.micro
AmiId:
Type: AWS::EC2::Image::Id
VpcId:
Type: AWS::EC2::VPC::Id
SubnetIds:
Type: List<AWS::EC2::Subnet::Id>
Resources:
InstanceSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for ASG instances
VpcId: !Ref VpcId
SecurityGroupEgress:
- CidrIp: 0.0.0.0/0
IpProtocol: "-1"
TargetGroup:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
Name: !Sub "${AWS::StackName}-tg"
Port: 80
Protocol: HTTP
VpcId: !Ref VpcId
HealthCheckPath: /health
TargetType: instance
LaunchTemplate:
Type: AWS::EC2::LaunchTemplate
Properties:
LaunchTemplateName: !Sub "${AWS::StackName}-lt"
ImageId: !Ref AmiId
InstanceType: !Ref InstanceType
SecurityGroupIds:
- !Ref InstanceSecurityGroup
AutoScalingGroup:
Type: AWS::AutoScaling::AutoScalingGroup
Properties:
AutoScalingGroupName: !Sub "${AWS::StackName}-asg"
MinSize: 2
MaxSize: 10
DesiredCapacity: 4
LaunchTemplate:
LaunchTemplateId: !Ref LaunchTemplate
Version: !GetAtt LaunchTemplate.LatestVersionNumber
VPCZoneIdentifier: !Ref SubnetIds
TargetGroupARNs:
- !Ref TargetGroup
HealthCheckType: ELB
HealthCheckGracePeriod: 300
Tags:
- Key: Name
Value: !Sub "${AWS::StackName}-instance"
PropagateAtLaunch: true
ScalingPolicy:
Type: AWS::AutoScaling::ScalingPolicy
Properties:
PolicyName: !Sub "${AWS::StackName}-cpu-policy"
PolicyType: TargetTrackingScaling
AutoScalingGroupName: !Ref AutoScalingGroup
TargetTrackingConfiguration:
PredefinedMetricSpecification:
PredefinedMetricType: ASGAverageCPUUtilization
TargetValue: 70
Outputs:
AutoScalingGroupName:
Value: !Ref AutoScalingGroup
Export:
Name: !Sub "${AWS::StackName}-ASG-Name"
Validation Commands
Validate template and test changes before deployment:
# Validate CloudFormation template
aws cloudformation validate-template --template-body file://template.yaml
# Create change set to preview changes
aws cloudformation create-change-set \
--stack-name my-asg-stack \
--template-body file://template.yaml \
--change-set-type CREATE
# Describe change set
aws cloudformation describe-change-set \
--stack-name my-asg-stack \
--change-set-name <change-set-id>
# Execute change set
aws cloudformation execute-change-set \
--stack-name my-asg-stack \
--change-set-name <change-set-id>
Verification Commands
Verify ASG health and configuration after deployment:
# Describe Auto Scaling Groups
aws autoscaling describe-auto-scaling-groups \
--auto-scaling-group-names my-asg-stack-asg
# Check instance health
aws autoscaling describe-auto-scaling-instances \
--instance-ids <instance-id>
# Verify scaling policies
aws autoscaling describe-policies \
--auto-scaling-group-name my-asg-stack-asg
# Review scaling activities
aws autoscaling describe-scaling-activities \
--auto-scaling-group-name my-asg-stack-asg
Constraints and Warnings
Resource Limits
- ASG max size: 10000 instances (request limit increase for more)
- Max 20 launch configurations per account (use Launch Templates instead)
- Lifecycle hooks: 50 per ASG
- Scaling policies: 20 per ASG (Target Tracking limit)
- Cooldown period: 300 seconds default (decrease cautiously)
Operational Warnings
- Do not update both Launch Configuration and Launch Template on the same ASG in one update
- Always use
UpdatePolicyfor graceful updates and instance refresh - Set
HealthCheckGracePeriod>= expected instance initialization time - Lifecycle hook timeout must accommodate graceful shutdown procedures
- Spot Instances: set
InstanceMaintenancePolicyto avoid unexpected terminations
Security Warnings
- Never hardcode credentials; use IAM instance profiles
- Use Service-Linked Roles for Auto Scaling (
aws-autoscaling.amazonaws.com) - Restrict ASG describe permissions to prevent information disclosure
- KMS keys for EBS encryption must be created in same region as ASG
- Cross-stack references export names must be unique per region
Best Practices
High Availability
- Distribute instances across multiple AZs
- Use ALB with health checks for automatic routing
- Implement lifecycle hooks for graceful shutdown
- Configure appropriate termination policies
- Use mixed instances policies for diversity
- Set appropriate health check grace periods
Cost Optimization
- Use Spot Instances for fault-tolerant workloads
- Implement right-sizing of instances
- Configure aggressive scale-in policies
- Use scheduled scaling for predictable patterns
- Monitor and optimize regularly
- Set appropriate minimum capacity to avoid over-provisioning
Monitoring
- Create CloudWatch Alarms for key metrics
- Implement scaling policies based on metrics
- Use lifecycle hooks for logging and analytics
- Configure SNS notifications for scaling events
- Implement detailed monitoring for troubleshooting
- Use multiple scaling policies for optimal response
Security
- Use IAM roles with least privilege permissions
- Encrypt EBS volumes with KMS
- Configure restrictive security groups
- Use VPC with appropriate subnets
- Implement Parameter Store for sensitive configuration
- Avoid broad managed policies (use specific permissions)
- Configure appropriate instance profiles
References
For detailed implementation guidance, see:
- constraints.md - Resource limits (ASG limits, scaling policy limits, lifecycle hook limits), scaling constraints (cooldown periods, health check grace periods, min/max capacity), operational constraints (mixed instances policy, predictive scaling, instance refresh), security constraints (IAM roles, service-linked roles, KMS permissions), and cost considerations (Spot instance termination, over-provisioning, scaling frequency)
Related Resources
AWS CloudFormation Amazon Bedrock
Overview
Creates production-ready AI infrastructure using AWS CloudFormation templates for Amazon Bedrock. Covers Bedrock agents, knowledge bases for RAG implementations, data source connectors, guardrails for content moderation, prompt management, workflow orchestration with flows, and inference profiles for optimized model access.
When to Use
- Creating Bedrock agents with action groups
- Implementing RAG with knowledge bases
- Configuring S3 or web crawl data sources
- Setting up content moderation guardrails
- Managing prompt templates
- Orchestrating AI workflows with Bedrock Flows
- Configuring inference profiles for multi-model access
- Organizing templates with Parameters and cross-stack references
Instructions
1. Define Parameters
Parameters:
FoundationModel:
Type: String
Default: anthropic.claude-3-sonnet-20240229-v1:0
AllowedValues:
- anthropic.claude-3-sonnet-20240229-v1:0
- anthropic.claude-3-haiku-20240307-v1:0
- amazon.titan-text-express-v1
Description: Foundation model for agent
2. Create Agent Role
Resources:
AgentRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: bedrock.amazonaws.com
Action: sts:AssumeRole
Policies:
- PolicyName: BedrockPermissions
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- bedrock:InvokeModel
Resource: !Sub "arn:aws:bedrock:${AWS::Region}:${AWS::AccountId}:foundation-model/${FoundationModel}"
3. Create Agent
BedrockAgent:
Type: AWS::Bedrock::Agent
Properties:
AgentName: !Sub "${AWS::StackName}-agent"
AgentResourceRoleArn: !GetAtt AgentRole.Arn
FoundationModelArn: !Sub "arn:aws:bedrock:${AWS::Region}::foundation-model/${FoundationModel}"
AutoPrepare: true
Instruction: |
You are a helpful assistant. Use the knowledge base to answer questions.
4. Create Knowledge Base
KnowledgeBaseRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: bedrock.amazonaws.com
Action: sts:AssumeRole
KnowledgeBase:
Type: AWS::Bedrock::KnowledgeBase
Properties:
Name: !Sub "${AWS::StackName}-kb"
RoleArn: !GetAtt KnowledgeBaseRole.Arn
KnowledgeBaseConfiguration:
Type: VECTOR
VectorKnowledgeBaseConfiguration:
EmbeddingModelArn: !Sub "arn:aws:bedrock:${AWS::Region}::embedding-model/amazon.titan-embed-text-v1"
5. Create Data Source
DataBucket:
Type: AWS::S3::Bucket
S3DataSource:
Type: AWS::Bedrock::DataSource
Properties:
KnowledgeBaseId: !Ref KnowledgeBase
Name: s3-data-source
Type: S3
DataSourceConfiguration:
S3Configuration:
BucketArn: !GetAtt DataBucket.Arn
InclusionPrefixes:
- documents/
6. Add Guardrail
Guardrail:
Type: AWS::Bedrock::Guardrail
Properties:
Name: !Sub "${AWS::StackName}-guardrail"
BlockedInputMessaging: "I cannot help with that request."
ContentPolicyConfig:
filtersConfig:
- type: PROFANITY
- type: MISCONDUCT
7. Create Action Group
ActionLambdaFunction:
Type: AWS::Lambda::Function
Properties:
Runtime: python3.12
Handler: index.handler
Role: !GetAtt ActionLambdaRole.Arn
Code:
ZipFile: |
def handler(event, context):
return {"statusCode": 200, "body": "{\"result\": \"success\"}"}
ActionGroup:
Type: AWS::Bedrock::AgentActionGroup
Properties:
ActionGroupName: api-operations
ActionGroupState: ENABLED
AgentId: !GetAtt BedrockAgent.AgentId
ActionGroupExecutor:
Lambda: !Ref ActionLambdaFunction
FunctionSchema:
functionConfigurations:
- function: |
{ "name": "get_inventory", "description": "Get current inventory status", "parameters": { "type": "object", "properties": { "sku": { "type": "string" } }, "required": [] } }
8. Validate Before Deploy
Always validate the template before deployment:
aws cloudformation validate-template --template-body file://bedrock-template.yaml
9. Verify After Deploy
# Check agent status
aws bedrock-agent get-agent --agent-id $(aws cloudformation describe-stacks --stack-name STACK_NAME --query 'Stacks[0].Outputs[?OutputKey==`AgentId`].OutputValue' --output text)
# Check knowledge base sync status
aws bedrock-agent list-knowledge-bases --agent-id AGENT_ID
# Test guardrail
aws bedrock-runtime apply_guardrail --guardrail-identifier GUARDRAIL_ID --source SOURCE
Examples
Minimal RAG Agent Template
Complete working template for a RAG-enabled agent:
AWSTemplateFormatVersion: "2010-09-09"
Description: "Bedrock RAG Agent with Knowledge Base"
Parameters:
FoundationModel:
Type: String
Default: anthropic.claude-3-sonnet-20240229-v1:0
Resources:
# IAM Role for Agent
AgentRole:
Type: AWS::IAM::Role
Properties:
RoleName: !Sub "${AWS::StackName}-agent-role"
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: bedrock.amazonaws.com
Action: sts:AssumeRole
Policies:
- PolicyName: InvokeModel
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action: bedrock:InvokeModel
Resource: "*"
# IAM Role for Knowledge Base
KnowledgeBaseRole:
Type: AWS::IAM::Role
Properties:
RoleName: !Sub "${AWS::StackName}-kb-role"
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: bedrock.amazonaws.com
Action: sts:AssumeRole
Policies:
- PolicyName: S3Access
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action: s3:GetObject
Resource: !Sub "${DataBucket.Arn}/*"
# S3 Bucket for Documents
DataBucket:
Type: AWS::S3::Bucket
# Knowledge Base
KnowledgeBase:
Type: AWS::Bedrock::KnowledgeBase
Properties:
Name: !Sub "${AWS::StackName}-kb"
RoleArn: !GetAtt KnowledgeBaseRole.Arn
KnowledgeBaseConfiguration:
Type: VECTOR
VectorKnowledgeBaseConfiguration:
EmbeddingModelArn: !Sub "arn:aws:bedrock:${AWS::Region}::embedding-model/amazon.titan-embed-text-v1"
# Data Source
DataSource:
Type: AWS::Bedrock::DataSource
Properties:
KnowledgeBaseId: !Ref KnowledgeBase
Name: !Sub "${AWS::StackName}-ds"
Type: S3
DataSourceConfiguration:
S3Configuration:
BucketArn: !GetAtt DataBucket.Arn
# Bedrock Agent
BedrockAgent:
Type: AWS::Bedrock::Agent
Properties:
AgentName: !Sub "${AWS::StackName}-agent"
AgentResourceRoleArn: !GetAtt AgentRole.Arn
FoundationModelArn: !Sub "arn:aws:bedrock:${AWS::Region}::foundation-model/${FoundationModel}"
AutoPrepare: true
Instruction: |
You are a helpful assistant. Use the knowledge base to answer user questions accurately.
Outputs:
AgentId:
Description: Bedrock Agent ID
Value: !GetAtt BedrockAgent.AgentId
KnowledgeBaseId:
Description: Knowledge Base ID
Value: !Ref KnowledgeBase
Guardrail with Content Filtering
Resources:
Guardrail:
Type: AWS::Bedrock::Guardrail
Properties:
Name: !Sub "${AWS::StackName}-guardrail"
blockedInputMessaging: "Content blocked by safety filters."
blockedOutputMessaging: "Response filtered for safety."
contentPolicyConfig:
filtersConfig:
- type: PROFANITY
inputStrength: HIGH
outputStrength: HIGH
- type: MISCONDUCT
inputStrength: HIGH
outputStrength: HIGH
sensitiveInformationPolicyConfig:
piiEntitiesConfig:
- type: EMAIL
action: ANONYMIZE
- type: SSN
action: BLOCK
Best Practices
Security
- Use least privilege IAM policies for agent and knowledge base roles
- Restrict web crawl data sources to trusted internal domains
- Encrypt sensitive data in knowledge bases
- Parameterize all TemplateURL values for nested stacks
Cost Optimization
- Select appropriate model size for task complexity
- Configure retrieval filtering to reduce token usage
- Set chunk size limits to control storage costs
- Monitor usage with CloudWatch dashboards
Performance
- Optimize chunk size for embedding quality
- Use provisioned throughput for high-traffic vector stores
- Configure appropriate knowledge base sync intervals
- Implement caching for frequently accessed content
Validation
- Always run
aws cloudformation validate-templatebefore deploy - Verify agent status after stack creation completes
- Test guardrails with sample inputs
- Monitor knowledge base sync status in CloudWatch
Constraints and Warnings
For detailed limits, see constraints.md:
- Regional limits: Not all models available in all regions
- Agent initialization: AutoPrepare may take several minutes
- Knowledge base sync: S3 sync is near-instant; web crawl takes longer
- Web crawl security: Always restrict to trusted domains to prevent prompt injection
- Token limits: Configure MaxTokens parameter for your use case
- Quota management: Request quota increases via AWS Support if needed
Security
- Restrict web crawl data sources to trusted internal domains only
- Validate content before ingesting into knowledge bases
- Use parameterized TemplateURL values for nested stacks
- Implement guardrails for content moderation
- Apply least privilege IAM policies to agent roles
- Encrypt sensitive data in knowledge bases
- Monitor for prompt injection in web-crawled content
Cost Optimization
- Use appropriate model selection for task complexity
- Implement knowledge base retrieval filtering
- Set chunk size limits to control token usage
- Monitor token consumption with CloudWatch
- Use auto-prepare agents strategically
- Implement batch processing for non-real-time workloads
- Use knowledge base filtering to reduce costs
Performance
- Optimize chunk size for embedding quality vs. cost
- Use vector store optimization (OpenSearch, Pinecone)
- Implement caching for frequently accessed knowledge base content
- Configure appropriate knowledge base sync intervals
- Use provisioned throughput for vector databases
- Monitor agent initialization and cold start times
- Implement graceful degradation for rate limiting
Data Management
- Use appropriate inclusion/exclusion filters for data sources
- Implement document validation before indexing
- Use versioning for knowledge base updates
- Configure appropriate sync intervals for data sources
- Implement content deduplication in knowledge bases
- Use metadata filtering for improved retrieval accuracy
- Monitor knowledge base size and document limits
References
- constraints.md - Resource limits, regional constraints, operational limits, and cost considerations
- reference.md - API reference and resource properties
- examples.md - Additional usage examples
Related Resources
AWS CloudFormation CloudFront CDN
Overview
Create production-ready CDN infrastructure using AWS CloudFormation templates. This skill covers CloudFront distributions, multiple origins (ALB, S3, API Gateway, Lambda@Edge, VPC Origins), CacheBehaviors, Functions, SecurityHeaders, and best practices for parameters, outputs, and cross-stack references.
When to Use
- Creating CloudFront distributions with CloudFormation
- Configuring origins (ALB, S3, Lambda@Edge, VPC Origins) with path patterns
- Implementing caching with CacheBehaviors and Cache Policies
- Configuring custom domains with ACM and SecurityHeaders
- Integrating WAF with CloudFront distributions
Instructions
Follow these steps to create CloudFront distributions with CloudFormation:
1. Define Distribution Parameters
Validate before deploying:
aws cloudformation validate-template --template-body file://template.yaml
cfn-lint template.yaml
Specify domain names, ACM certificates, price class, and origin settings:
Parameters:
DomainName:
Type: String
Default: cdn.example.com
Description: Custom domain name for CloudFront distribution
CertificateArn:
Type: AWS::ACM::Certificate::Arn
Description: ACM certificate ARN for HTTPS
PriceClass:
Type: String
Default: PriceClass_All
AllowedValues:
- PriceClass_All
- PriceClass_100
- PriceClass_200
Description: CloudFront price class
OriginDomainName:
Type: String
Description: Domain name of the origin (ALB or S3)
2. Configure Origins
Add S3 buckets, ALBs, API Gateway, or custom origins. For S3 origins, use OAI (legacy) or OAC (recommended):
Resources:
# S3 Bucket
StaticBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: !Sub "static-assets-${AWS::AccountId}-${AWS::Region}"
PublicAccessBlockConfiguration:
BlockPublicAcls: true
BlockPublicPolicy: true
# Origin Access Control (recommended)
OriginAccessControl:
Type: AWS::CloudFront::OriginAccessControl
Properties:
OriginAccessControlConfig:
Name: !Sub "${AWS::StackName}-oac"
OriginAccessControlOriginType: s3
SigningBehavior: always
SigningProtocol: sigv4
3. Set Up Default Cache Behavior
Configure viewer request/response policies and caching:
Resources:
CloudFrontDistribution:
Type: AWS::CloudFront::Distribution
Properties:
DistributionConfig:
Origins:
- Id: S3Origin
DomainName: !GetAtt StaticBucket.RegionalDomainName
AccessControlId: !Ref OriginAccessControl
S3OriginConfig:
OriginAccessIdentity: ""
DefaultCacheBehavior:
TargetOriginId: S3Origin
ViewerProtocolPolicy: redirect-to-https
AllowedMethods:
- GET
- HEAD
CachedMethods:
- GET
- HEAD
Compress: true
CachePolicyId: !Ref CachePolicy
4. Add Additional Cache Behaviors
Create path-specific caching rules for different content types:
Resources:
ApiCachePolicy:
Type: AWS::CloudFront::CachePolicy
Properties:
CachePolicyConfig:
Name: !Sub "${AWS::StackName}-api-cache"
DefaultTTL: 300
MaxTTL: 600
MinTTL: 60
CloudFrontDistribution:
Type: AWS::CloudFront::Distribution
Properties:
DistributionConfig:
CacheBehaviors:
- PathPattern: "/api/*"
TargetOriginId: ApiOrigin
CachePolicyId: !GetAtt ApiCachePolicy.Id
AllowedMethods:
- GET
- HEAD
- OPTIONS
- PUT
- POST
5. Configure Security Settings
Implement security headers and WAF integration:
Resources:
SecurityHeadersPolicy:
Type: AWS::CloudFront::ResponseHeadersPolicy
Properties:
ResponseHeadersPolicyConfig:
Name: !Sub "${AWS::StackName}-security-headers"
SecurityHeadersConfig:
StrictTransportSecurity:
AccessControlMaxAgeSec: 31536000
IncludeSubdomains: true
Override: true
FrameOptions:
FrameOption: DENY
Override: true
WAFWebACL:
Type: AWS::WAFv2::WebACL
Properties:
Name: !Sub "${AWS::StackName}-waf"
Scope: CLOUDFRONT
DefaultAction:
Allow: {}
6. Add CloudFront Functions
Configure functions for request/response manipulation:
Resources:
RewritePathFunction:
Type: AWS::CloudFront::Function
Properties:
Name: !Sub "${AWS::StackName}-rewrite-path"
FunctionCode: |
function handler(event) {
var request = event.request;
// Function code here
return request;
}
Runtime: cloudfront-js-1.0
AutoPublish: true
7. Configure Monitoring
Set up logging and access logs to S3:
Resources:
AccessLogsBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: !Sub "cloudfront-logs-${AWS::AccountId}"
CloudFrontDistribution:
Type: AWS::CloudFront::Distribution
Properties:
DistributionConfig:
Logging:
Bucket: !Ref AccessLogsBucket
Prefix: cloudfront-logs/
IncludeCookies: false
8. Create Outputs
Export distribution details for cross-stack references:
Outputs:
DistributionDomainName:
Description: CloudFront distribution domain name
Value: !GetAtt CloudFrontDistribution.DomainName
Export:
Name: !Sub "${AWS::StackName}-DistributionDomainName"
DistributionId:
Description: CloudFront distribution ID
Value: !Ref CloudFrontDistribution
Export:
Name: !Sub "${AWS::StackName}-DistributionId"
Best Practices
Security
- Always use HTTPS with minimum TLS 1.2
- Implement SecurityHeaders with HSTS, XSS protection
- Use WAF for protection against common attacks
- Configure appropriate Access-Control for CORS
- Limit origin access with OAI/OAC
- Use Signed URLs for private content
- Implement rate limiting
- Configure geo-restrictions if needed
Performance
- Use appropriate PriceClass to optimize costs
- Configure Cache TTL based on content type
- Enable compression (Gzip/Brotli)
- Use CloudFront Functions for lightweight operations
- Optimize header forwarding (do not forward unnecessary headers)
- Consider Origin Shield to reduce load on origins
- Use multiple origins with path patterns
Monitoring
- Enable CloudWatch metrics and alarms
- Configure real-time logs for troubleshooting
- Monitor cache hit ratio
- Configure alerts for error rate and latency
- Use CloudFront reports for traffic analysis
Deployment
- Use change sets before deployment
- Test templates with cfn-lint
- Organize stacks by lifecycle and ownership
- Implement blue/green deployments with weighted aliases
- Use StackSets for multi-region deployment
Template Structure
- Use AWS-specific parameter types (AWS::ACM::Certificate::Arn, AWS::S3::Bucket::RegionalDomainName)
- Implement parameter constraints (MinLength, MaxLength, AllowedValues, AllowedPattern)
- Use Conditions for environment-specific configuration
- Leverage Mappings for region-specific configuration
- Apply Metadata for parameter grouping and labels
- Use nested stacks for modularity
Cache Strategy
- Use Cache Policies for different content types
- Configure Origin Request Policies to control what's sent to origin
- Set appropriate TTL values:
- Static assets: 86400-31536000 seconds (1 day to 1 year)
- API responses: 60-600 seconds (1-10 minutes)
- Dynamic content: 0 seconds (no caching)
- Enable compression for text-based content
- Use versioned paths for cache busting
Constraints and Warnings
- ACM certificates: Must be in
us-east-1(N. Virginia) for CloudFront - Limits: Max 200 distributions per AWS account, 25 origins per distribution, 25 cache behaviors per distribution
- Deployment time: CloudFront distributions take up to 30 minutes to deploy; plan accordingly
- Certificate requirements: Max 100 alternate domain names per distribution; include default domain for SSL
- OAI deprecation: Prefer Origin Access Control (OAC) over Origin Access Identity (OAI) for S3 origins
- Lambda@Edge limits: 128MB memory, 30s timeout for viewer request/response; separate limits apply for origin requests
- Change sets: Always use change sets before deploying to preview resource changes and avoid accidental deletions
- Drift detection: CloudFormation does not detect drift for CloudFront distributions — manage all settings in templates
Examples
Minimal S3 Static Site Distribution
AWSTemplateFormatVersion: "2010-09-09"
Resources:
S3Bucket:
Type: AWS::S3::Bucket
Properties:
BucketName: !Sub "cdn-static-${AWS::AccountId}"
PublicAccessBlockConfiguration:
BlockPublicAcls: true
BlockPublicPolicy: true
OriginAccessControl:
Type: AWS::CloudFront::OriginAccessControl
Properties:
OriginAccessControlConfig:
Name: !Sub "${AWS::StackName}-oac"
OriginAccessControlOriginType: s3
SigningBehavior: always
SigningProtocol: sigv4
CloudFrontDistribution:
Type: AWS::CloudFront::Distribution
Properties:
DistributionConfig:
Enabled: true
DefaultRootObject: index.html
Origins:
- Id: S3Origin
DomainName: !GetAtt S3Bucket.RegionalDomainName
AccessControlId: !Ref OriginAccessControl
DefaultCacheBehavior:
TargetOriginId: S3Origin
ViewerProtocolPolicy: redirect-to-https
Compress: true
CachePolicyId: 658327ea-f89d-4fab-a63d-7e88639e58f6
PriceClass: PriceClass_All
HttpVersion: http2and3
Outputs:
DistributionDomainName:
Value: !GetAtt CloudFrontDistribution.DomainName
Multi-Origin with Cache Behaviors
Resources:
CachePolicyApi:
Type: AWS::CloudFront::CachePolicy
Properties:
CachePolicyConfig:
Name: !Sub "${AWS::StackName}-api"
DefaultTTL: 300
MaxTTL: 600
MinTTL: 60
CloudFrontDistribution:
Type: AWS::CloudFront::Distribution
Properties:
DistributionConfig:
Origins:
- Id: S3Origin
DomainName: !GetAtt StaticBucket.RegionalDomainName
AccessControlId: !Ref OriginAccessControl
- Id: ApiOrigin
DomainName: !GetAtt ApiLoadBalancer.DNSName
CustomOriginConfig:
OriginProtocolPolicy: https-only
HTTPPort: 80
HTTPSPort: 443
CacheBehaviors:
- PathPattern: "/api/*"
TargetOriginId: ApiOrigin
CachePolicyId: !GetAtt CachePolicyApi.Id
ViewerProtocolPolicy: https-only
- PathPattern: "/static/*"
TargetOriginId: S3Origin
CachePolicyId: 658327ea-f89d-4fab-a63d-7e88639e58f6
References
For detailed implementation guidance, see:
-
template-structure.md - Complete template structure, AWS-specific parameter types, parameter constraints, SSM parameter references, metadata for parameter grouping, transform for macros, conditions for environment-specific configuration, nested stacks, and cross-stack references with export/import patterns
-
origins.md - Origin configuration including S3 origins with OAI/OAC, ALB origins with security groups, API Gateway origins (REST and HTTP APIs), Lambda@Edge origins, VPC origins with Global Accelerator, custom origins, and multi-origin configurations with path patterns
-
caching.md - Cache policies (managed, custom, images, videos), origin request policies, response headers policies, cache behaviors configuration, forwarded values (query strings, headers, cookies), cache key configuration, and TTL configuration best practices
-
security.md - Security headers (CSP, HSTS, XSS protection), CORS configuration, WAF integration with managed and custom rules, origin access control (OAI vs OAC), signed URLs and signed cookies, geo-restrictions, HTTPS enforcement, TLS configuration, and field-level encryption
-
advanced-features.md - CloudFront Functions (viewer request, viewer response, origin request), Lambda@Edge for authentication and URL rewriting, geo-restrictions, price class optimization, compression (Gzip and Brotli), real-time logs to Kinesis and S3, custom error pages, function associations, and Origin Shield configuration
-
constraints.md - Resource limits (200 distributions max, 25 origins max, 25 cache behaviors max), DNS and certificate constraints (ACM in us-east-1, 300 alternate domain names), operational constraints (15 invalidations max, 30 min deployment), security constraints (HTTPS, CSP, WAF), and cost considerations (data transfer, regional pricing, Lambda@Edge costs)
Related Resources
AWS CloudFormation CloudWatch Monitoring
Overview
Creates CloudWatch monitoring infrastructure using CloudFormation templates: metrics, alarms, dashboards, log groups, anomaly detection, synthesized canaries, and Application Signals.
When to Use
- Creating CloudWatch metrics and alarms for production infrastructure
- Building CloudWatch dashboards for multi-region visualization
- Implementing log groups with retention, encryption, and metric filters
- Configuring anomaly detection and composite alarms
- Setting up cross-stack references with Parameters and Outputs
- Validating and deploying monitoring stacks with CloudFormation
Instructions
Follow these steps to create CloudWatch monitoring infrastructure with CloudFormation:
1. Define Alarm Parameters
Specify metric namespaces, dimensions, and threshold values:
Parameters:
ErrorRateThreshold:
Type: Number
Default: 5
Description: Error rate threshold for alarms (percentage)
LatencyThreshold:
Type: Number
Default: 1000
Description: Latency threshold in milliseconds
CpuUtilizationThreshold:
Type: Number
Default: 80
Description: CPU utilization threshold (percentage)
LogRetentionDays:
Type: Number
Default: 30
AllowedValues:
- 1
- 3
- 7
- 14
- 30
- 60
- 90
- 120
- 365
Description: Number of days to retain log events
2. Create CloudWatch Alarms
Set up alarms for CPU, memory, disk, and custom metrics:
Resources:
HighCpuAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: !Sub "${AWS::StackName}-high-cpu"
AlarmDescription: Trigger when CPU utilization exceeds threshold
MetricName: CPUUtilization
Namespace: AWS/EC2
Dimensions:
- Name: InstanceId
Value: !Ref InstanceId
Statistic: Average
Period: 60
EvaluationPeriods: 3
Threshold: !Ref CpuUtilizationThreshold
ComparisonOperator: GreaterThanThreshold
AlarmActions:
- !Ref AlarmTopic
ErrorRateAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: !Sub "${AWS::StackName}-error-rate"
MetricName: ErrorRate
Namespace: !Ref CustomNamespace
Dimensions:
- Name: Service
Value: !Ref ServiceName
Statistic: Average
Period: 60
EvaluationPeriods: 5
Threshold: !Ref ErrorRateThreshold
ComparisonOperator: GreaterThanThreshold
3. Configure Alarm Actions
Define SNS topics for notification delivery:
Resources:
AlarmNotificationTopic:
Type: AWS::SNS::Topic
Properties:
DisplayName: !Sub "${AWS::StackName}-alarms"
TopicName: !Sub "${AWS::StackName}-alarms"
AlarmTopicPolicy:
Type: AWS::SNS::TopicPolicy
Properties:
PolicyDocument:
Statement:
- Effect: Allow
Principal:
Service: cloudwatch.amazonaws.com
Action: sns:Publish
Resource: !Ref AlarmNotificationTopic
Topics:
- !Ref AlarmNotificationTopic
4. Create Dashboards
Build visualization widgets for metrics across resources:
Resources:
MonitoringDashboard:
Type: AWS::CloudWatch::Dashboard
Properties:
DashboardName: !Sub "${AWS::StackName}-dashboard"
DashboardBody: !Sub |
{
"widgets": [
{
"type": "metric",
"x": 0,
"y": 0,
"width": 12,
"height": 6,
"properties": {
"title": "CPU Utilization",
"metrics": [["AWS/EC2", "CPUUtilization", "InstanceId", "${InstanceId}"]],
"period": 300,
"stat": "Average",
"region": "${AWS::Region}"
}
}
]
}
5. Set Up Log Groups
Configure retention policies and encryption settings:
Resources:
ApplicationLogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/applications/${Environment}/${ApplicationName}"
RetentionInDays: !Ref LogRetentionDays
KmsKeyId: !Ref LogEncryptionKey
6. Implement Metric Filters
Create metrics from log data:
Resources:
ErrorMetricFilter:
Type: AWS::Logs::MetricFilter
Properties:
LogGroupName: !Ref ApplicationLogGroup
FilterPattern: '[level="ERROR", msg]'
MetricTransformations:
- MetricValue: "1"
MetricNamespace: !Sub "${AWS::StackName}/Application"
MetricName: ErrorCount
7. Add Composite Alarms
Build multi-condition alarm logic:
Resources:
SystemHealthComposite:
Type: AWS::CloudWatch::CompositeAlarm
Properties:
AlarmName: !Sub "${AWS::StackName}-system-health"
AlarmRule: !Or
- !Ref HighCpuAlarm
- !Ref ErrorRateAlarm
AlarmActions:
- !Ref AlarmTopic
8. Configure Log Insights Queries
Create saved queries for log analysis:
Resources:
ErrorAnalysisQuery:
Type: AWS::Logs::QueryDefinition
Properties:
Name: !Sub "${AWS::StackName}-errors"
LogGroupNames:
- !Ref ApplicationLogGroup
QueryString: |
fields @timestamp, @message
| filter @message like /ERROR/
| sort @timestamp desc
| limit 100
9. Validate Template
Before deploying, validate the CloudFormation template:
aws cloudformation validate-template --template-body file://template.yaml
For parameterized templates, test with sample values:
aws cloudformation validate-template \
--template-body file://monitoring.yaml \
--capabilities CAPABILITY_IAM
10. Deploy and Verify
Deploy the stack and verify resources:
# Deploy stack
aws cloudformation create-stack \
--stack-name my-monitoring-stack \
--template-body file://monitoring.yaml \
--parameters file://parameters.json \
--capabilities CAPABILITY_IAM
# Wait for completion
aws cloudformation wait stack-create-complete \
--stack-name my-monitoring-stack
# Verify alarms are in OK state
aws cloudwatch describe-alarms --stack-name my-monitoring-stack
# Check dashboard accessibility
aws cloudwatch get-dashboard --dashboard-name my-monitoring-stack-dashboard
Test alarm actions before production:
# Set alarm to testing state
aws cloudwatch set-alarm-state \
--alarm-name my-alarm \
--state-value ALARM \
--state-reason "Testing alarm action"
Best Practices
- Use composite alarms to reduce noise and avoid false positives
- Set meaningful thresholds based on baseline metrics
- Configure appropriate evaluation periods (3-5 datapoints)
- Enable anomaly detection for metrics with variable patterns
- Use metric math for derived metrics (error rates, latency percentiles)
- Set appropriate log retention based on compliance needs
- Encrypt log groups with sensitive data using KMS
- Test alarm actions with
set-alarm-statebefore production
Examples
Example 1: Complete Monitoring Stack
AWSTemplateFormatVersion: '2010-09-09'
Description: Complete CloudWatch monitoring setup
Parameters:
Environment:
Type: String
Default: prod
AllowedValues: [dev, staging, prod]
Resources:
# SNS Topic for notifications
AlarmTopic:
Type: AWS::SNS::Topic
Properties:
DisplayName: !Sub "${Environment}-alarms"
# Alarm for high CPU
CpuAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: !Sub "${AWS::StackName}-cpu-high"
MetricName: CPUUtilization
Namespace: AWS/EC2
Statistic: Average
Period: 300
EvaluationPeriods: 2
Threshold: 80
ComparisonOperator: GreaterThanThreshold
AlarmActions:
- !Ref AlarmTopic
# Dashboard
Dashboard:
Type: AWS::CloudWatch::Dashboard
Properties:
DashboardName: !Ref AWS::StackName
DashboardBody: !Sub |
{
"widgets": [{
"type": "metric",
"properties": {
"metrics": [["AWS/EC2", "CPUUtilization"]],
"period": 300,
"stat": "Average"
}
}]
}
Example 2: Log-Based Metrics with Filters
Resources:
AppLogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/app/${Environment}"
RetentionInDays: 30
ErrorMetricFilter:
Type: AWS::Logs::MetricFilter
Properties:
LogGroupName: !Ref AppLogGroup
FilterPattern: '"ERROR"'
MetricTransformations:
- MetricValue: "1"
MetricNamespace: !Sub "${AWS::StackName}/App"
MetricName: ErrorCount
ErrorAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: !Sub "${AWS::StackName}-errors"
MetricName: ErrorCount
MetricNamespace: !Sub "${AWS::StackName}/App"
Statistic: Sum
Period: 300
EvaluationPeriods: 1
Threshold: 1
ComparisonOperator: GreaterThanOrEqualToThreshold
Constraints and Warnings
Resource Limits
- Maximum 5000 alarms per account
- Maximum 50 metric filters per log group
- Dashboard body limited to 512KB
- Maximum 200 metrics per alarm expression
Security Considerations
- Enable encryption on log groups containing sensitive data
- Use IAM policies to restrict alarm action permissions
- Avoid hardcoding thresholds in templates; use Parameters
- Protect SNS topics with encryption and access policies
Operational Warnings
- High-resolution alarms (10s/30s) incur higher costs
- Missing data treatment affects alarm state; configure explicitly
- Composite alarms can mask individual alarm states
- Metric filters are immutable after creation; recreate to change
Cost Optimization
- Use standard resolution (5-minute period) unless necessary
- Set appropriate retention periods (shorter = cheaper)
- Delete unused dashboards and custom metrics
- Monitor CloudWatch charges with budgets and alerts
Monitoring Strategy
- Use composite alarms to reduce alarm noise
- Configure appropriate evaluation periods to avoid false positives
- Set up anomaly detection for metrics with variable patterns
- Use metric math for derived metrics (error rates, averages)
- Implement high-resolution alarms for critical metrics
- Create separate dashboards for different audiences (ops, dev, management)
Log Management
- Use appropriate retention periods based on compliance requirements
- Encrypt log groups containing sensitive data
- Implement metric filters for critical log patterns
- Set up cross-account log aggregation for centralized analysis
- Use CloudWatch Logs Insights for troubleshooting
- Configure log subscriptions to Lambda/Kinesis for real-time processing
Alarm Configuration
- Set meaningful thresholds based on baseline metrics
- Use datapoints-to-alarm for reliability
- Configure OK actions to reset notifications
- Treat missing data appropriately (breaching, not breaching, ignore)
- Test alarm actions regularly
- Document alarm runbooks and escalation procedures
Template Structure
- Use AWS-specific parameter types for resources
- Implement parameter constraints for validation
- Use Conditions for environment-specific configuration
- Leverage Mappings for region-specific settings
- Apply Metadata for parameter grouping
- Use nested stacks for large monitoring setups
Dashboard Design
- Organize dashboards by service or application tier
- Use consistent widget layouts and sizing
- Include text widgets for context and documentation
- Set appropriate time ranges for data visualization
- Use variables for dynamic dashboard filtering
- Limit metrics per dashboard to avoid performance issues
References
For detailed implementation guidance, see:
-
alarms.md - CloudWatch metrics and alarms including base metric alarms, latency alarms, API Gateway errors, EC2 instance alarms, Lambda function alarms, composite alarms, anomaly detection, metric math, alarm actions (SNS, Auto Scaling, EC2), missing data treatment, custom metrics, metric filters, and high-resolution alarms
-
dashboards.md - CloudWatch dashboards including base template, service-specific dashboards, widget types (metric, log, text, single value, alarm status), multi-region dashboards, stacked metrics, anomaly detection widgets, math expressions, layout patterns (grid, row, column), dynamic variables, cross-account sharing, and dashboard automation
-
logs.md - CloudWatch logs including log group configurations, metric filters, subscription filters (Lambda, Kinesis Firehose), cross-account log aggregation, log insights queries, resource policies, export and archive tasks, CloudWatch agent configuration, log encryption with KMS, lifecycle management, centralized logging, and search patterns
-
constraints.md - Resource limits (5000 alarms max, 500 dashboards max), operational constraints (metric resolution, evaluation periods, dashboard widgets, cross-account), security constraints (log data access, encryption, metric filters, alarm actions), cost considerations (detailed monitoring, custom metrics, log retention, dashboard queries), and data constraints (metric age, log ingestion, filter limits)
Related Resources
AWS CloudFormation DynamoDB Patterns
Provides production-ready NoSQL database infrastructure patterns using AWS CloudFormation templates with DynamoDB tables, GSIs, LSIs, auto-scaling, encryption, TTL, and streams.
Overview
Covers DynamoDB tables, primary keys, secondary indexes (GSI/LSI), capacity modes, auto-scaling, encryption, TTL, streams, and best practices for parameters, outputs, and cross-stack references.
When to Use
Creating DynamoDB tables, configuring keys and indexes, setting capacity modes, implementing auto-scaling, enabling encryption/TTL/streams, and organizing CloudFormation templates.
Instructions
Follow these steps to create DynamoDB tables with CloudFormation:
- Define Table Parameters: Specify table name and billing mode
- Configure Primary Key: Set partition key and optional sort key
- Add Secondary Indexes: Create GSIs for alternative access patterns
- Configure Encryption: Enable encryption using KMS keys
- Set Up TTL: Define timestamp attribute for automatic deletion
- Enable Streams: Configure stream for change data capture
- Add Auto Scaling: Implement Application Auto Scaling for provisioned capacity
- Create Backup: Enable point-in-time recovery
- Validate Template: Run
aws cloudformation validate-templatebefore deployment - Deploy Stack: Use
aws cloudformation create-stackorupdate-stack - Monitor Events: Check
aws cloudformation describe-stack-eventsfor failures orROLLBACKstatus - Handle Rollback: On failure, review events for resource errors, fix the template, and re-deploy
Quick Reference
| Resource Type | Purpose |
|---|---|
AWS::DynamoDB::Table | Create DynamoDB table |
AWS::ApplicationAutoScaling::ScalableTarget | Auto scaling configuration |
AWS::ApplicationAutoScaling::ScalingPolicy | Scaling policies |
AWS::KMS::Key | KMS key for encryption |
AWS::IAM::Role | IAM roles for auto scaling |
| BillingMode | PAY_PER_REQUEST or PROVISIONED |
| SSESpecification | Server-side encryption |
Examples
Basic Table with On-Demand Capacity
DynamoDBTable:
Type: AWS::DynamoDB::Table
Properties:
TableName: !Sub "${AWS::StackName}-table"
BillingMode: PAY_PER_REQUEST
AttributeDefinitions:
- AttributeName: pk
AttributeType: S
KeySchema:
- AttributeName: pk
KeyType: HASH
Table with Global Secondary Index
DynamoDBTable:
Type: AWS::DynamoDB::Table
Properties:
TableName: !Sub "${AWS::StackName}-table"
BillingMode: PAY_PER_REQUEST
AttributeDefinitions:
- AttributeName: pk
AttributeType: S
- AttributeName: gsi-pk
AttributeType: S
KeySchema:
- AttributeName: pk
KeyType: HASH
GlobalSecondaryIndexes:
- IndexName: gsi-index
KeySchema:
- AttributeName: gsi-pk
KeyType: HASH
Projection:
ProjectionType: ALL
Table with TTL
SessionTable:
Type: AWS::DynamoDB::Table
Properties:
TableName: !Sub "${AWS::StackName}-sessions"
BillingMode: PAY_PER_REQUEST
AttributeDefinitions:
- AttributeName: sessionId
AttributeType: S
KeySchema:
- AttributeName: sessionId
KeyType: HASH
TimeToLiveSpecification:
AttributeName: expiresAt
Enabled: true
Table with Auto Scaling
ScalableTarget:
Type: AWS::ApplicationAutoScaling::ScalableTarget
Properties:
MaxCapacity: 100
MinCapacity: 5
ResourceId: !Sub "table/${DynamoDBTable}"
RoleARN: !GetAtt AutoScalingRole.Arn
ScalableDimension: dynamodb:table:ReadCapacityUnits
ServiceNamespace: dynamodb
See references/complete-examples.md for more complete examples including encryption, streams, auto scaling, and production tables.
Template Structure
Base Template
AWSTemplateFormatVersion: 2010-09-09
Description: DynamoDB table with GSI and auto-scaling
Parameters:
TableName:
Type: String
Default: my-table
BillingMode:
Type: String
Default: PAY_PER_REQUEST
Resources:
DynamoDBTable:
Type: AWS::DynamoDB::Table
Properties:
TableName: !Ref TableName
BillingMode: !Ref BillingMode
Outputs:
TableName:
Value: !Ref DynamoDBTable
TableArn:
Value: !GetAtt DynamoDBTable.Arn
See references/advanced-configuration.md for detailed Parameters, Mappings, Conditions, Outputs, IAM roles, and cross-stack references.
Best Practices
- Use PAY_PER_REQUEST for development/testing and unpredictable workloads
- Enable Point-In-Time Recovery for production tables
- Use KMS encryption for sensitive data (SSE-KMS)
- Configure auto-scaling for provisioned capacity tables
- Design GSIs carefully - each GSI consumes capacity
- Use TTL for automatic data expiration (sessions, cache)
- Enable Streams for change data capture and analytics
- Tag resources for cost allocation and organization
- Export outputs for cross-stack references
- Use Conditions for environment-specific configurations
Common Troubleshooting
Table already exists: Use unique table names or stack deletion policy GSI creation fails: Verify attribute definitions include GSI attributes Auto-scaling not working: Check IAM role permissions and service-linked role TTL not expiring: Ensure TTL attribute is Number type, not String Streams not enabled: Can only enable streams during table creation Encryption errors: Verify KMS key exists in same region as table
Related Skills
- aws-cloudformation-security - Security best practices for DynamoDB
- aws-cloudformation-lambda - Lambda triggers for DynamoDB Streams
- aws-cloudformation-iam - IAM roles for DynamoDB access
References
Complete Examples
- references/complete-examples.md - Basic tables, GSI, LSI, TTL, encryption, PITR, auto-scaling, production tables, global tables, streams
Advanced Configuration
- references/advanced-configuration.md - Parameters, Mappings, Conditions, auto scaling policies, streams, TTL, global tables, outputs, IAM roles, deletion policies
Constraints and Warnings
- Table names: Must be unique per region (globally unique for global tables)
- GSI limits: Maximum 5 GSIs per table (for single-region tables)
- LSI limits: Maximum 5 LSIs per table, same partition key as table
- Capacity limits: On-demand has default account limits (40,000 RCUs, 40,000 WCUs)
- Auto-scaling: Requires PROVISIONED billing mode (not PAY_PER_REQUEST)
- Point-in-time recovery: Can only be enabled during table creation
- Streams: Can only be enabled during table creation
- Encryption: KMS keys must be in same region as table
- TTL: Attribute must be Number type, measured in seconds
- Throughput: Each GSI shares provisioned throughput with table
- Item size limit: Maximum 400 KB per item
- Hot partition: Design keys to avoid hot partition issues
AWS CloudFormation EC2 Infrastructure
Overview
Create production-ready EC2 infrastructure using AWS CloudFormation templates. Covers EC2 instances (On-Demand and SPOT), Security Groups, IAM roles, Application Load Balancers (ALB), template structure, parameters, outputs, and cross-stack references.
When to Use
- Creating EC2 instances (On-Demand or SPOT) with Security Groups and IAM roles
- Setting up Application Load Balancers with target groups
- Implementing template Parameters, Mappings, Conditions, and cross-stack references
Instructions
Step 1 — Define Template Parameters
Use AWS-specific parameter types for validation and console dropdowns.
Parameters:
LatestAmiId:
Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
Default: /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2
InstanceType:
Type: AWS::EC2::InstanceType
Default: t3.micro
AllowedValues: [t3.micro, t3.small, t3.medium]
KeyName:
Type: AWS::EC2::KeyPair::KeyName
See template-structure.md for advanced parameter patterns, mappings, conditions, and cross-stack references.
Step 2 — Create Security Group
Define ingress/egress rules for network access.
InstanceSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for EC2 instance
VpcId: !Ref VpcId
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
- IpProtocol: tcp
FromPort: 22
ToPort: 22
CidrIp: 10.0.0.0/16
See security-iam.md for advanced security group patterns, self-references, and IAM roles.
Step 3 — Configure IAM Role
Define instance profile with least privilege permissions.
Ec2Role:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: ec2.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
Ec2InstanceProfile:
Type: AWS::IAM::InstanceProfile
Properties:
Roles: [!Ref Ec2Role]
See security-iam.md for least privilege policies, SSM roles, and trust policies.
Step 4 — Launch EC2 Instance
Configure instance with security group, IAM role, and user data.
Ec2Instance:
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref LatestAmiId
InstanceType: !Ref InstanceType
KeyName: !Ref KeyName
SecurityGroupIds: [!Ref InstanceSecurityGroup]
IamInstanceProfile: !Ref Ec2InstanceProfile
SubnetId: !Ref SubnetId
UserData:
Fn::Base64: |
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
Tags:
- Key: Name
Value: !Sub ${AWS::StackName}-instance
See ec2-instances.md for multi-volume configurations, detailed monitoring, SPOT instances, and complete stack examples.
Validate template: aws cloudformation validate-template --template-body file://template.yaml
Step 5 — Add Application Load Balancer
Create ALB with target group and listener for traffic distribution.
ApplicationLoadBalancer:
Type: AWS::ElasticLoadBalancingV2::LoadBalancer
Properties:
Name: !Sub ${AWS::StackName}-alb
Scheme: internet-facing
SecurityGroups: [!Ref AlbSecurityGroup]
Subnets: [!Ref PublicSubnet1, !Ref PublicSubnet2]
ApplicationTargetGroup:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
Port: 80
Protocol: HTTP
VpcId: !Ref VpcId
HealthCheckPath: /health
ApplicationListener:
Type: AWS::ElasticLoadBalancingV2::Listener
Properties:
DefaultActions:
- Type: forward
TargetGroupArn: !Ref ApplicationTargetGroup
LoadBalancerArn: !Ref ApplicationLoadBalancer
Port: 80
Protocol: HTTP
See load-balancers.md for HTTPS configuration, path-based routing, host-based routing, listener rules, and ALB attributes.
Step 6 — Define Outputs
Export values for cross-stack references.
Outputs:
InstanceId:
Description: EC2 Instance ID
Value: !Ref Ec2Instance
Export:
Name: !Sub ${AWS::StackName}-InstanceId
SecurityGroupId:
Description: Security Group ID
Value: !Ref InstanceSecurityGroup
Export:
Name: !Sub ${AWS::StackName}-SecurityGroupId
LoadBalancerDnsName:
Description: ALB DNS Name
Value: !GetAtt ApplicationLoadBalancer.DNSName
See template-structure.md for cross-stack reference patterns and import/export strategies.
Examples
Minimal EC2 with ALB Template
AWSTemplateFormatVersion: "2010-09-09"
Description: EC2 instance with ALB
Parameters:
LatestAmiId:
Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
Default: /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2
InstanceType:
Type: AWS::EC2::InstanceType
Default: t3.micro
Resources:
InstanceSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Enable HTTP and SSH
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
Ec2Instance:
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref LatestAmiId
InstanceType: !Ref InstanceType
SecurityGroupIds: [!Ref InstanceSecurityGroup]
LoadBalancer:
Type: AWS::ElasticLoadBalancingV2::LoadBalancer
Properties:
Scheme: internet-facing
SecurityGroups: [!Ref InstanceSecurityGroup]
Subnets: [subnet-12345678, subnet-87654321]
Outputs:
InstanceId:
Value: !Ref Ec2Instance
LoadBalancerDns:
Value: !GetAtt LoadBalancer.DNSName
Deploy with Change Set
# Create change set
aws cloudformation create-change-set \
--stack-name my-ec2-stack \
--template-body file://template.yaml \
--change-set-type CREATE
# Execute after review
aws cloudformation execute-change-set \
--change-set-name <change-set-name>
See examples.md for complete production-ready templates.
Best Practices
Template Structure
- Use AWS-specific parameter types for validation (
AWS::EC2::VPC::Id,AWS::EC2::InstanceType) - Organize by lifecycle - separate network, security, and application stacks
- Use meaningful names with
AWS::StackNameprefix - Enable termination protection on production stacks
Security
- Apply least privilege to IAM roles - grant minimum required permissions
- Use security group references instead of IP addresses where possible
- Enable IMDSv2 on all EC2 instances
- Restrict security group rules to specific CIDR blocks
Cost & Availability
- Use SPOT instances for fault-tolerant, interruptible workloads
- Deploy across multiple AZs for high availability
- Set up CloudWatch alarms for CPU and status checks
- Use EBS gp3 volumes for cost-effective storage
Operations
- Always use change sets for production stack updates
- Enable drift detection to maintain template compliance
- Apply stack policies to protect critical resources
- Validate templates before deployment with
aws cloudformation validate-template
See best-practices.md for detailed guidance on stack policies, termination protection, drift detection, change set automation, and validation scripts.
References
Core Configuration
- template-structure.md — Template sections, parameters, mappings, conditions, outputs, cross-stack references
- ec2-instances.md — EC2 instances, SPOT fleets, multi-volume configurations, complete stack examples
- security-iam.md — Security groups, IAM roles, instance profiles, least privilege policies
- load-balancers.md — ALB configuration, target groups, listeners, path-based routing, HTTPS
Operational Guides
- best-practices.md — Stack policies, termination protection, drift detection, change sets, validation
- constraints.md — Resource limits, instance constraints, cost considerations, common issues, monitoring
Additional Resources
- examples.md — Complete production-ready examples and use cases
- reference.md — CloudFormation EC2 resource reference documentation
Constraints and Warnings
Resource Limits
- Maximum 500 resources per CloudFormation stack
- Maximum 500 security groups per VPC
- Instance types vary by region/A availability
Cost Considerations
- EC2 instances incur costs while running
- EBS volumes charged per GB-month even when not attached
- ALBs have hourly + LCU data processing costs
- Unattached Elastic IPs incur hourly costs
Security Considerations
- Key pairs cannot be recovered if lost
- Instance profile roles cannot be changed after creation
- IMDSv1 has security vulnerabilities - use IMDSv2
- Spot instances can be terminated with 2-minute notice
See constraints.md for complete constraints, troubleshooting guides, and monitoring setup.
AWS CloudFormation ECS
Overview
Provides CloudFormation patterns for ECS clusters, task definitions, services, container definitions, auto scaling, blue/green deployments, ALB integration, monitoring, and cross-stack references.
When to Use
- Creating or updating ECS clusters with CloudFormation
- Configuring Fargate/EC2 launch types and capacity providers
- Deploying services with ALB/NLB integration or blue/green deployments
- Implementing auto scaling for ECS services
- Setting up monitoring with Container Insights
Instructions
Follow these steps to create ECS infrastructure with CloudFormation:
1. Define ECS Cluster Parameters
Specify launch type, networking, and capacity settings:
Parameters:
LaunchType:
Type: String
Default: FARGATE
AllowedValues:
- EC2
- FARGATE
Description: ECS launch type
ContainerPort:
Type: Number
Default: 80
Description: Container port
TaskCPU:
Type: String
Default: 256
AllowedValues:
- 256
- 512
- 1024
- 2048
- 4096
Description: Task CPU units
TaskMemory:
Type: String
Default: 512
AllowedValues:
- 512
- 1024
- 2048
- 3072
- 4096
- 5120
- 6144
- 7168
- 8192
- 9216
- 10240
Description: Task memory in MB
2. Create ECS Cluster
Define the cluster infrastructure:
Resources:
ECSCluster:
Type: AWS::ECS::Cluster
Properties:
ClusterName: !Sub "${AWS::StackName}-cluster"
ClusterSettings:
- Name: containerInsights
Value: enabled
CapacityProviders:
- FARGATE
- FARGATE_SPOT
DefaultCapacityProviderStrategy:
- CapacityProvider: FARGATE
Weight: 1
- CapacityProvider: FARGATE_SPOT
Weight: 0
3. Create Task Definition
Define container configurations:
Resources:
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
Family: !Sub "${AWS::StackName}-task"
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
Cpu: !Ref TaskCPU
Memory: !Ref TaskMemory
ExecutionRoleArn: !Ref ExecutionRole
TaskRoleArn: !Ref TaskRole
ContainerDefinitions:
- Name: application
Image: !Ref ImageUrl
PortMappings:
- ContainerPort: !Ref ContainerPort
Protocol: tcp
Environment:
- Name: LOG_LEVEL
Value: INFO
LogConfiguration:
LogDriver: awslogs
Options:
awslogs-group: !Ref LogGroup
awslogs-region: !Ref AWS::Region
awslogs-stream-prefix: ecs
Memory: !Ref TaskMemory
Validate task definition syntax before proceeding:
aws cloudformation validate-template --template-body file://template.yaml
4. Configure Execution Roles
Set up IAM roles for task execution:
Resources:
ExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: ecs-tasks.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
TaskRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: ecs-tasks.amazonaws.com
Action: sts:AssumeRole
Policies:
- PolicyName: S3Access
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- s3:GetObject
Resource: !Sub "${DataBucket.Arn}/*"
5. Create ECS Service
Define the service configuration:
Resources:
ECSService:
Type: AWS::ECS::Service
Properties:
ServiceName: !Sub "${AWS::StackName}-service"
Cluster: !Ref ECSCluster
TaskDefinition: !Ref TaskDefinition
DesiredCount: 2
LaunchType: FARGATE
NetworkConfiguration:
AwsvpcConfiguration:
Subnets:
- !Ref PrivateSubnet1
- !Ref PrivateSubnet2
SecurityGroups:
- !Ref SecurityGroup
AssignPublicIp: DISABLED
LoadBalancers:
- TargetGroupArn: !Ref TargetGroup
ContainerName: application
ContainerPort: !Ref ContainerPort
6. Configure Load Balancer
Set up ALB for traffic distribution:
Resources:
LoadBalancer:
Type: AWS::ElasticLoadBalancingV2::LoadBalancer
Properties:
Name: !Sub "${AWS::StackName}-alb"
Scheme: internet-facing
Type: application
Subnets:
- !Ref PublicSubnet1
- !Ref PublicSubnet2
SecurityGroups:
- !Ref ALBSecurityGroup
TargetGroup:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
Port: 80
Protocol: HTTP
VpcId: !Ref VPC
TargetType: ip
Listener:
Type: AWS::ElasticLoadBalancingV2::Listener
Properties:
DefaultActions:
- TargetGroupArn: !Ref TargetGroup
Type: forward
LoadBalancerArn: !Ref LoadBalancer
Port: 80
Protocol: HTTP
7. Implement Auto Scaling
Configure Application Auto Scaling:
Resources:
ScalableTarget:
Type: AWS::ApplicationAutoScaling::ScalableTarget
Properties:
MaxCapacity: 10
MinCapacity: 1
ResourceId: !Sub "service/${ECSCluster}/${ECSService}"
ScalableDimension: ecs:service:DesiredCount
ServiceNamespace: ecs
ScalingPolicy:
Type: AWS::ApplicationAutoScaling::ScalingPolicy
Properties:
PolicyName: !Sub "${AWS::StackName}-scaling"
PolicyType: TargetTrackingScaling
ScalingTargetId: !Ref ScalableTarget
TargetTrackingScalingPolicyConfiguration:
TargetValue: 70.0
PredefinedMetricSpecification:
PredefinedMetricType: ECSServiceAverageCPUUtilization
8. Configure Monitoring
Enable CloudWatch Container Insights:
Resources:
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/ecs/${AWS::StackName}"
RetentionInDays: 7
Before deployment: Create a change set to preview changes:
aws cloudformation create-change-set \
--stack-name my-ecs-stack \
--template-body file://template.yaml \
--change-set-type CREATE
aws cloudformation execute-change-set --change-set-name <arn>
Best Practices
Task Definition
- Use
Familynaming for version tracking and immutable deployments - Keep task definition under 1 KB (CloudFormation limit) by referencing external configs
- Configure
HealthCheckin container definitions for ECS health monitoring - Set both
CpuandMemoryat task level for Fargate
Service Deployment
- Enable
DeploymentCircuitBreakerfor automatic rollback on failures - Use
HealthCheckGracePeriodSecondsmatching application startup time - Configure
MinimumHealthyPercent(100) andMaximumPercent(200) for zero-downtime updates - Reference task definition by logical ID only—ECS automatically uses latest revision
Networking
- Always use
awsvpcnetwork mode for Fargate - Place tasks in private subnets with NAT gateway for outbound access
- Configure security groups to allow only required ports (not 0.0.0.0/0)
Scaling
- Use Fargate Spot with base capacity of 1 on-demand for cost optimization
- Set
MaxHealthyDurationon capacity provider strategy for Spot interruption handling - Monitor
STEADY_STATEfailures in CloudWatch for task startup issues
Constraints and Warnings
Resource Limits
- Task definition size limit: 1 KB when using CloudFormation (use ParameterStore/Secrets Manager for large configs)
- Maximum 10 containers per task definition in Fargate
- CPU must be specified for Fargate tasks (256-4096 units, in 1024 increments)
- Memory must be allocated (512-30720 MB depending on CPU)
Operational Limits
- ENI limits apply per subnet—plan for at least 1 ENI per task in each AZ
- Fargate Spot tasks receive 2-minute interruption notice—implement graceful shutdown signals (SIGTERM)
- Service updates require new task definition revision—cannot modify existing versions
DesiredCountupdates during deployment may conflict with auto scaling policies
CloudFormation-Specific
- Cross-stack references required for VPC IDs, Subnet IDs, and Security Group IDs passed between stacks
- Use
!GetAttfor referencing stack outputs in same template - Ensure IAM role ARNs use
Fn::Subwith stack name for portability
Examples
Minimal Fargate Service
AWSTemplateFormatVersion: "2010-09-09"
Description: Minimal ECS Fargate service
Resources:
Cluster:
Type: AWS::ECS::Cluster
Properties:
ClusterName: !Sub "${AWS::StackName}-cluster"
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
Family: !Sub "${AWS::StackName}-task"
NetworkMode: awsvpc
RequiresCompatibilities: [FARGATE]
Cpu: 256
Memory: 512
ContainerDefinitions:
- Name: app
Image: nginx:latest
PortMappings:
- ContainerPort: 80
Service:
Type: AWS::ECS::Service
Properties:
Cluster: !Ref Cluster
ServiceName: !Sub "${AWS::StackName}-svc"
TaskDefinition: !Ref TaskDefinition
DesiredCount: 2
LaunchType: FARGATE
DeploymentCircuitBreaker:
Enable: true
Rollback: true
ECS with ALB Integration
Resources:
Service:
Type: AWS::ECS::Service
Properties:
Cluster: !Ref ECSCluster
TaskDefinition: !Ref TaskDefinition
DesiredCount: 2
LaunchType: FARGATE
HealthCheckGracePeriodSeconds: 30
NetworkConfiguration:
AwsvpcConfiguration:
Subnets: [!Ref PrivateSubnet1, !Ref PrivateSubnet2]
SecurityGroups: [!Ref TaskSecurityGroup]
LoadBalancers:
- TargetGroupArn: !Ref TargetGroup
ContainerName: app
ContainerPort: 8080
TargetGroup:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
Port: 80
Protocol: HTTP
VpcId: !Ref VPC
TargetType: ip
HealthCheckPath: /health
References
For detailed implementation guidance, see:
- constraints.md - Resource limits (task definition size, container limits, memory limits, CPU limits), operational constraints (service updates, ENI limits, task start time, scaling delays), security constraints (IAM roles, network mode, security groups, secrets rotation), cost considerations (Fargate pricing, data transfer, ECR storage, monitoring), deployment constraints (blue/green requirements, CodeDeploy integration, rollbacks, task drift), and availability constraints (Fargate Spot, multi-AZ, health checks, service discovery)
Related Resources
AWS CloudFormation ElastiCache
Overview
Use this skill to model ElastiCache infrastructure with CloudFormation without turning SKILL.md into a full service manual.
Focus on the delivery decisions that matter most:
- choosing the right cache topology
- placing the cache safely inside a VPC
- configuring availability, encryption, and exports for downstream stacks
Use the bundled references/ documents for larger production templates and service-specific detail.
When to Use
Use this skill when:
- creating a Redis or Memcached cache tier with CloudFormation
- deciding between
AWS::ElastiCache::CacheClusterandAWS::ElastiCache::ReplicationGroup - configuring subnet groups, parameter groups, and security groups for application access
- adding snapshots, maintenance windows, encryption, and Multi-AZ behavior
- exporting cache endpoints to application or platform stacks
- reviewing cache changes for replacement risk, downtime, or operational cost
Typical trigger phrases include cloudformation elasticache, redis replication group, memcached cluster, cache subnet group, and export redis endpoint.
Instructions
1. Choose the cache topology first
Use:
ReplicationGroupfor production Redis-style deployments that need failover, replicas, or shardingCacheClusterfor Memcached or simple single-node cache scenarios
Do not start with resource YAML before deciding whether the application needs durability, read replicas, cluster mode, or just an ephemeral cache.
2. Model the network boundary explicitly
Create and wire:
- a subnet group with private application subnets
- a security group that allows access only from the application tier
- parameter groups only when default engine settings are insufficient
Keep the cache private unless there is a very unusual and well-reviewed reason not to.
3. Configure durability and security based on environment
For production-style Redis deployments, decide on:
- automatic failover and Multi-AZ
- at-rest and in-transit encryption
- snapshot retention and maintenance windows
- authentication or auth token strategy where supported
For lower environments, document when a cheaper single-node configuration is acceptable.
4. Add reusable parameters and outputs
Parameterize only the settings that truly vary between environments, such as node type, subnet IDs, or snapshot retention.
Export outputs that other stacks need, typically:
- primary or configuration endpoint
- reader endpoint when applicable
- security group or subnet group identifiers only if downstream stacks genuinely depend on them
5. Validate the stack change before rollout
Before deployment:
- run template validation
- inspect whether changes replace the cluster or replication group
- review security group exposure and encryption settings
- confirm maintenance, backup, and scaling choices match the application's recovery expectations
Examples
Example 1: Redis replication group with private networking
Parameters:
CacheNodeType:
Type: String
Default: cache.t4g.small
Resources:
CacheSubnetGroup:
Type: AWS::ElastiCache::SubnetGroup
Properties:
Description: Private subnets for the cache tier
SubnetIds: !Ref PrivateSubnetIds
CacheSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Application access to Redis
VpcId: !Ref VpcId
RedisReplicationGroup:
Type: AWS::ElastiCache::ReplicationGroup
Properties:
ReplicationGroupDescription: Application Redis cluster
Engine: redis
CacheNodeType: !Ref CacheNodeType
NumNodeGroups: 1
ReplicasPerNodeGroup: 1
AutomaticFailoverEnabled: true
MultiAZEnabled: true
CacheSubnetGroupName: !Ref CacheSubnetGroup
SecurityGroupIds:
- !Ref CacheSecurityGroup
TransitEncryptionEnabled: true
AtRestEncryptionEnabled: true
Example 2: Export an endpoint for another stack
Outputs:
RedisPrimaryEndpoint:
Description: Primary endpoint used by the application stack
Value: !GetAtt RedisReplicationGroup.PrimaryEndPoint.Address
Export:
Name: !Sub "${AWS::StackName}-RedisPrimaryEndpoint"
Keep outputs small and stable so consumer stacks do not break unnecessarily.
Best Practices
- Prefer replication groups over single-node Redis for production systems.
- Put caches in private subnets and restrict ingress to known application security groups.
- Turn on encryption and snapshots unless there is a documented reason not to.
- Review replacement risk before changing engine version, cluster mode, or subnet design.
- Use parameters for environment-specific sizing, not for every possible knob.
- Keep deep template variants in
references/examples.mdinstead of expanding the root skill endlessly.
Constraints and Warnings
- Some ElastiCache changes cause replacement or data loss if applied carelessly.
- NAT, subnet, and routing mistakes can make the cache unreachable even when the stack succeeds.
- Multi-AZ, replicas, and larger node types can change cost significantly.
- Cache endpoints, encryption support, and auth features vary by engine and version.
- Snapshot and maintenance windows must align with the application's recovery and deployment practices.
References
references/examples.mdreferences/reference.md
Related Skills
aws-cloudformation-vpcaws-cloudformation-securityaws-cloudformation-ecsaws-cloudformation-lambda
AWS CloudFormation IAM Security
Overview
Use this skill to model IAM with CloudFormation in a way that stays secure, auditable, and maintainable.
The most important design concerns are:
- separating trust policies from permission policies
- preferring roles over long-lived users wherever possible
- keeping least-privilege boundaries readable and reusable
Do not treat SKILL.md as a full IAM encyclopedia. Use the bundled references for larger policy examples and service-specific variants.
When to Use
- Creating IAM roles for Lambda, ECS, EC2, Step Functions, or other AWS services
- Defining inline policies, managed policies, and permission boundaries in CloudFormation
- Modeling cross-account assume-role access with constrained trust policies
- Exporting IAM role ARNs or managed policy ARNs to downstream stacks
- Reviewing wildcard permissions, boundary drift, or role replacement risk
- Creating reusable IAM stacks for platform or application teams
Instructions
1. Define the trust boundary first
Identify who or what assumes the role (service principal, cross-account principal, or federated identity), then write the trust policy with explicit principals and conditions before adding permissions.
2. Grant the minimum permission set
Use inline policies for role-specific access; use managed policies for shared patterns across principals. Scope actions and resources tightly, and use conditions where possible.
3. Apply permission boundaries for delegated role creation
Use permission boundaries when teams create or extend roles in their own stacks, when guardrails are needed around privileged services (IAM, KMS, Organizations), or to separate maximum allowed permissions from application-specific policies.
Name roles and policies consistently so stack outputs and audits remain easy to trace.
4. Model cross-account access
For cross-account roles: trust only the exact source account or principal, add sts:ExternalId conditions when appropriate, keep permission and trust policies separate, and export only the ARNs that consuming accounts need.
5. Validate the template and policy behavior
Before rollout, use these commands to verify the template and IAM behavior:
# Validate CloudFormation template syntax
aws cloudformation validate-template --template-body file://template.yaml
# Preview changes before applying
aws cloudformation create-change-set \
--stack-name <stack-name> \
--template-body file://template.yaml \
--change-set-type CREATE
# Simulate whether a principal can perform specific actions
aws iam simulate-principal-policy \
--policy-source-arn arn:aws:iam::123456789012:role/LambdaExecutionRole \
--action-names dynamodb:GetItem dynamodb:PutItem
# Check for wildcards in IAM policies within the template
aws cloudformation list-stack-resources --stack-name <stack-name>
After deployment, confirm policy attachments and stack outputs match the intended security model.
Examples
Example 1: Service role for Lambda with tightly scoped permissions
Resources:
LambdaExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
Policies:
- PolicyName: DynamoDbWritePolicy
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- dynamodb:GetItem
- dynamodb:PutItem
Resource: !GetAtt OrdersTable.Arn
Example 2: Cross-account role with an external ID condition
Resources:
PartnerReadRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
AWS: arn:aws:iam::123456789012:role/partner-reader
Action: sts:AssumeRole
Condition:
StringEquals:
sts:ExternalId: partner-contract-001
Keep the trust relationship narrow and pair it with a separate read-only permission policy.
Best Practices
- Prefer IAM roles over long-lived IAM users for application and automation access.
- Separate trust policies from permission policies when reviewing or refactoring templates.
- Use permission boundaries when delegating role creation to other teams.
- Scope resources, actions, and conditions as tightly as the workload allows.
- Export stable ARNs and names only when another stack truly consumes them.
- Keep expanded policy libraries and edge cases in
references/instead of bloating the root skill.
Constraints and Warnings
- Overly broad wildcards in IAM are easy to deploy and hard to notice later.
- Named IAM resources can be hard to replace safely once other systems depend on them.
- IAM changes may appear successful in CloudFormation before eventual consistency settles across AWS services.
- Some Identity Center or organization-wide access patterns need complementary tooling outside a single CloudFormation stack.
- Misconfigured trust policies are often a bigger risk than missing permissions.
References
references/examples.mdreferences/reference.md
Related Skills
aws-cloudformation-securityaws-cloudformation-ec2aws-cloudformation-ecsaws-cloudformation-lambda
AWS CloudFormation Lambda Functions
Overview
Create production-ready Lambda functions using CloudFormation templates with validation and deployment workflows.
When to Use
- Creating Lambda functions with CloudFormation
- Configuring event sources (S3, SQS, DynamoDB, Kinesis)
- Implementing Lambda layers and cold start optimization
- Integrating Lambda with API Gateway
- Deploying Lambda infrastructure with validation
Deployment Workflow
Always follow this deployment workflow:
1. Validate Template
aws cloudformation validate-template --template-body file://template.yaml
2. Deploy Stack
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-lambda-stack \
--capabilities CAPABILITY_IAM \
--parameter-overrides Environment=prod
3. Monitor Stack Events
aws cloudformation describe-stack-events \
--stack-name my-lambda-stack \
--query 'StackEvents[?ResourceStatus==`CREATE_FAILED`||ResourceStatus==`UPDATE_FAILED`]'
4. Verify Resources
aws lambda get-function --function-name my-lambda-stack-function
aws cloudformation describe-stacks --stack-name my-lambda-stack \
--query 'Stacks[0].StackStatus'
5. Rollback on Failure
aws cloudformation delete-stack --stack-name my-lambda-stack
aws logs describe-log-groups --log-group-name-prefix "/aws/lambda/my-lambda"
Instructions
Follow these steps to create Lambda functions with CloudFormation:
1. Define Lambda Function Parameters
Specify runtime, memory, timeout, and environment variables:
Parameters:
FunctionMemory:
Type: Number
Default: 256
AllowedValues:
- 128
- 256
- 512
- 1024
- 2048
Description: Lambda function memory in MB
FunctionTimeout:
Type: Number
Default: 30
MinValue: 1
MaxValue: 900
Description: Function timeout in seconds
Runtime:
Type: String
Default: nodejs20.x
AllowedValues:
- nodejs20.x
- python3.11
- java21
- dotnet8
- go1.x
Description: Lambda runtime environment
2. Create Lambda Function
Define the basic function configuration:
Resources:
LambdaFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: !Sub "${AWS::StackName}-function"
Runtime: !Ref Runtime
Handler: index.handler
Role: !Ref ExecutionRole
MemorySize: !Ref FunctionMemory
Timeout: !Ref FunctionTimeout
Code:
S3Bucket: !Ref CodeBucket
S3Key: !Ref CodeKey
Environment:
Variables:
LOG_LEVEL: INFO
DATABASE_URL: !Ref DatabaseUrl
Tags:
- Key: Environment
Value: !Ref Environment
3. Configure Execution Role
Apply least privilege IAM policies:
Resources:
ExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Policies:
- PolicyName: S3ReadAccess
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- s3:GetObject
Resource: !Sub "${DataBucket.Arn}/*"
4. Add Event Sources
Configure triggers for Lambda invocation:
Resources:
# S3 event source
S3EventSource:
Type: AWS::Lambda::EventSourceMapping
Properties:
EventSourceArn: !GetAtt DataBucket.Arn
FunctionName: !Ref LambdaFunction
# SQS event source
SQSEventSource:
Type: AWS::Lambda::EventSourceMapping
Properties:
EventSourceArn: !GetAtt Queue.Arn
FunctionName: !Ref LambdaFunction
BatchSize: 10
MaximumBatchingWindowInSeconds: 5
5. Configure API Gateway Integration
Set up REST or HTTP API integration:
Resources:
# HTTP API integration
HttpApi:
Type: AWS::ApiGatewayV2::Api
Properties:
Name: !Sub "${AWS::StackName}-api"
ProtocolType: HTTP
Target: !Ref LambdaFunction
ApiIntegration:
Type: AWS::ApiGatewayV2::Integration
Properties:
ApiId: !Ref HttpApi
IntegrationType: AWS_PROXY
IntegrationUri: !Sub "arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${LambdaFunction.Arn}/invocations"
6. Implement Versioning and Aliases
Create function versions and aliases:
Resources:
LambdaVersion:
Type: AWS::Lambda::Version
Properties:
FunctionName: !Ref LambdaFunction
Description: !Sub "Version ${AWS::StackName} v1"
LambdaAlias:
Type: AWS::Lambda::Alias
Properties:
FunctionName: !Ref LambdaFunction
FunctionVersion: !GetAtt LambdaVersion.Version
Name: live
7. Configure Monitoring
Enable CloudWatch logging and X-Ray tracing:
Resources:
LambdaFunction:
Type: AWS::Lambda::Function
Properties:
LoggingConfig:
LogGroup: !Ref LogGroup
TracingConfig:
Mode: Active
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/lambda/${LambdaFunction}"
RetentionInDays: 7
8. Set Up Dead Letter Queue
Configure DLQ for failed invocations:
Resources:
DeadLetterQueue:
Type: AWS::SQS::Queue
Properties:
QueueName: !Sub "${AWS::StackName}-dlq"
LambdaFunction:
Type: AWS::Lambda::Function
Properties:
DeadLetterConfig:
TargetArn: !GetAtt DeadLetterQueue.Arn
Examples
Complete Lambda Stack Template
AWSTemplateFormatVersion: '2010-09-09'
Description: Lambda function with monitoring and DLQ
Parameters:
FunctionMemory:
Type: Number
Default: 256
AllowedValues: [128, 256, 512, 1024]
FunctionTimeout:
Type: Number
Default: 30
Resources:
ExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal: { Service: lambda.amazonaws.com }
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
LambdaFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: !Sub "${AWS::StackName}-function"
Runtime: nodejs20.x
Handler: index.handler
Role: !GetAtt ExecutionRole.Arn
MemorySize: !Ref FunctionMemory
Timeout: !Ref FunctionTimeout
Code:
S3Bucket: !Ref CodeBucket
S3Key: !Ref CodeKey
Environment:
Variables:
LOG_LEVEL: INFO
LambdaVersion:
Type: AWS::Lambda::Version
Properties:
FunctionName: !Ref LambdaFunction
LambdaAlias:
Type: AWS::Lambda::Alias
Properties:
FunctionName: !Ref LambdaFunction
FunctionVersion: !GetAtt LambdaVersion.Version
Name: live
Outputs:
FunctionArn:
Value: !GetAtt LambdaFunction.Arn
FunctionName:
Value: !Ref LambdaFunction
Best Practices
Performance Optimization
- Use SnapStart for Java functions to eliminate cold starts
- Use provisioned concurrency for critical functions requiring low latency
- Keep deployment packages small (< 50 MB zipped)
- Optimize memory size based on function requirements
- Use appropriate timeout values (avoid maximum timeout)
- Configure reserved concurrency to prevent throttling
Cost Optimization
- Right-size memory allocation for cost efficiency
- Use provisioned concurrency strategically (adds cost when idle)
- Monitor Lambda duration and optimize for faster execution
- Use ephemeral storage (/tmp) efficiently
- Clean up unused Lambda functions and versions
- Consider Lambda PowerTuning for optimal memory/power configuration
Security
- Apply least privilege IAM policies to execution roles
- Encrypt environment variables at rest
- Use VPC endpoints for private AWS service access
- Rotate IAM credentials regularly
- Implement VPC configuration for private function access
- Use AWS KMS for encrypting sensitive data
Reliability
- Configure Dead Letter Queue for async invocations
- Implement retry logic with exponential backoff
- Use CloudWatch alarms for error monitoring
- Test Lambda functions thoroughly before deployment
- Implement circuit breakers for downstream service failures
- Use canary deployments with Lambda aliases
Monitoring and Observability
- Enable CloudWatch Logs for all functions
- Use X-Ray tracing for distributed tracing
- Configure CloudWatch metrics for performance monitoring
- Set up alarms for errors, throttles, and duration
- Use Lambda Insights for debugging
- Monitor concurrent executions and throttling
Versioning and Deployment
- Use Lambda aliases for production environments (live, staging)
- Implement canary deployments with weighted aliases
- Create function versions for immutable deployments
- Use SAM or AWS CDK for simplified Lambda deployments
- Implement blue/green deployments with Lambda aliases
- Test function changes in development environment first
Constraints and Warnings
- Timeout limits: Lambda timeout max is 900 seconds (15 min); set appropriate values to avoid orphaned executions
- Deployment package size: Zipped packages max 50 MB, unzipped max 250 MB (including layers)
- Layer limits: Max 5 layers per function; each layer max 50 MB (unzipped)
- Environment variables: Max 4 KB for all variables; encrypt sensitive values with KMS
- Cold starts: Java and .NET functions have longer cold starts; use SnapStart or Provisioned Concurrency for latency-sensitive workloads
- Concurrent execution: Default limit 1000 per region; request increase for high-traffic functions
- VPC networking: Lambda in VPC adds 10-30 second cold start overhead for first invocation
- IAM permissions: Never use
*in Resource policies; always scope to specific resources - Dead Letter Queue: Required for async invocations; ensure DLQ is in same region as function
- Cost monitoring: Enable billing alerts; Lambda charges per invocation and duration
References
For detailed implementation guidance, see:
- constraints.md - Resource limits (function limits, concurrent execution, timeout, memory), deployment constraints (function size, layer size, environment variables), operational constraints (cold starts, VPC networking, event sources, DLQ), security constraints (execution role, resource policies, VPC endpoints), cost considerations (provisioned concurrency, duration, memory, data transfer), and performance constraints (SnapStart, layer versioning, X-Ray tracing, async invocation)
Related Resources
AWS CloudFormation RDS Database
Overview
Create production-ready Amazon RDS infrastructure using AWS CloudFormation templates. Covers RDS instances (MySQL, PostgreSQL, Aurora), DB clusters, multi-AZ deployments, parameter groups, subnet groups, security groups, and cross-stack references.
When to Use
- Creating RDS instances (MySQL, PostgreSQL, Aurora) or DB clusters with read replicas
- Setting up multi-AZ deployments or configuring parameter/subnet groups
- Integrating with Secrets Manager or implementing cross-stack references
Quick Reference
| Component | CloudFormation Type | Use Case |
|---|---|---|
| DB Instance | AWS::RDS::DBInstance | Single database instance |
| DB Cluster | AWS::RDS::DBCluster | Aurora cluster |
| DB Subnet Group | AWS::RDS::DBSubnetGroup | VPC deployment |
| Parameter Group | AWS::RDS::DBParameterGroup | Database configuration |
| Security Group | AWS::EC2::SecurityGroup | Network access control |
| Secrets Manager | AWS::SecretsManager::Secret | Credential storage |
Instructions
Step 1 — Define Database Parameters
Use AWS-specific parameter types for validation.
Parameters:
DBInstanceClass:
Type: AWS::RDS::DBInstance::InstanceType
Default: db.t3.micro
AllowedValues: [db.t3.micro, db.t3.small, db.t3.medium]
Engine:
Type: String
Default: mysql
AllowedValues: [mysql, postgres, aurora-mysql, aurora-postgresql]
MasterUsername:
Type: String
Default: admin
AllowedPattern: "^[a-zA-Z][a-zA-Z0-9]*$"
MinLength: 1
MaxLength: 16
MasterUserPassword:
Type: String
NoEcho: true
MinLength: 8
MaxLength: 41
See template-structure.md for advanced parameter patterns, mappings, conditions, and cross-stack references.
Step 2 — Create DB Subnet Group
Required for VPC deployment with subnets in different AZs.
DBSubnetGroup:
Type: AWS::RDS::DBSubnetGroup
Properties:
DBSubnetGroupDescription: Subnet group for RDS
SubnetIds:
- !Ref PrivateSubnet1
- !Ref PrivateSubnet2
See database-components.md for parameter groups, option groups, and engine-specific configurations.
Step 3 — Configure Security Group
Restrict access to application tier only.
DBSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for RDS
VpcId: !Ref VpcId
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 3306
ToPort: 3306
SourceSecurityGroupId: !Ref AppSecurityGroup
See security-secrets.md for VPC security groups, encryption, Secrets Manager integration, and IAM authentication.
Step 4 — Launch RDS Instance
Configure instance with subnet group, security group, and settings.
DBInstance:
Type: AWS::RDS::DBInstance
Properties:
DBInstanceIdentifier: !Sub "${AWS::StackName}-mysql"
DBInstanceClass: !Ref DBInstanceClass
Engine: !Ref Engine
MasterUsername: !Ref MasterUsername
MasterUserPassword: !Ref MasterUserPassword
AllocatedStorage: 20
StorageType: gp3
DBSubnetGroupName: !Ref DBSubnetGroup
VPCSecurityGroups: [!Ref DBSecurityGroup]
StorageEncrypted: true
MultiAZ: true
BackupRetentionPeriod: 7
DeletionProtection: false
See database-components.md for MySQL, PostgreSQL, Aurora cluster configurations, and parameter groups.
Step 5 — Enable High Availability
Configure multi-AZ deployment for production.
Conditions:
IsProduction: !Equals [!Ref Environment, production]
Resources:
DBInstance:
Type: AWS::RDS::DBInstance
Properties:
MultiAZ: !If [IsProduction, true, false]
BackupRetentionPeriod: !If [IsProduction, 35, 7]
DeletionProtection: !If [IsProduction, true, false]
EnablePerformanceInsights: !If [IsProduction, true, false]
See high-availability.md for multi-AZ deployments, read replicas, Aurora auto-scaling, enhanced monitoring, and disaster recovery.
Step 6 — Define Outputs
Export connection details for application stacks.
Outputs:
DBInstanceEndpoint:
Description: Database endpoint address
Value: !GetAtt DBInstance.Endpoint.Address
Export:
Name: !Sub ${AWS::StackName}-DBEndpoint
DBInstancePort:
Description: Database port
Value: !GetAtt DBInstance.Endpoint.Port
Export:
Name: !Sub ${AWS::StackName}-DBPort
DBConnectionString:
Description: Connection string
Value: !Sub jdbc:mysql://${DBInstance.Endpoint.Address}:${DBInstance.Endpoint.Port}/${DBName}
See template-structure.md for cross-stack reference patterns and import/export strategies.
Validation Steps
Always validate before deploying, especially to production.
# Validate the template syntax
aws cloudformation validate-template --template-body file://template.yaml
# Review the change set before applying updates
aws cloudformation create-change-set \
--stack-name my-rds-stack \
--template-body file://template.yaml \
--change-set-type UPDATE
aws cloudformation describe-change-set --change-set-name <arn>
# Execute the change set if the preview looks correct
aws cloudformation execute-change-set --change-set-name <arn>
Best Practices
| Category | Practice | Implementation |
|---|---|---|
| Security | Encryption at rest | StorageEncrypted: true with KMS key |
| Security | Credential management | Use Secrets Manager integration |
| Security | Network isolation | Private subnets, restrictive SG rules |
| Security | IAM authentication | Enable IAMDatabaseAuthentication |
| HA | Multi-AZ deployment | MultiAZ: true for production |
| HA | Deletion protection | DeletionProtection: true for production |
| HA | Backup retention | 35 days for production, 7 for dev |
| HA | Read replicas | Use for read-heavy workloads |
| Cost | Storage type | Use gp3 for cost efficiency |
| Cost | Instance sizing | Right-size based on workload |
| Cost | Serverless | Consider Aurora Serverless for variable loads |
| Operations | Change sets | Always review before applying updates |
| Operations | Drift detection | Enable for template compliance |
| Operations | Monitoring | Configure CloudWatch alarms |
See operational-practices.md for detailed guidance on stack policies, termination protection, and backup strategies.
Examples
Complete production-ready RDS instance with MultiAZ, encryption, and Secrets Manager integration:
AWSTemplateFormatVersion: '2010-09-09'
Description: Production RDS Instance
Parameters:
VpcId:
Type: AWS::EC2::VPC::Identifier
SubnetIds:
Type: List<AWS::EC2::Subnet::Identifier>
AppSecurityGroupId:
Type: AWS::EC2::SecurityGroup::Id
Environment:
Type: String
AllowedValues: [dev, staging, production]
MasterUsername:
Type: String
Default: dbadmin
Conditions:
IsProduction: !Equals [!Ref Environment, production]
Resources:
DBSubnetGroup:
Type: AWS::RDS::DBSubnetGroup
Properties:
DBSubnetGroupDescription: !Sub "${AWS::StackName} subnet group"
SubnetIds: !Ref SubnetIds
DBSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: !Sub "${AWS::StackName} RDS security group"
VpcId: !Ref VpcId
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 3306
ToPort: 3306
SourceSecurityGroupId: !Ref AppSecurityGroupId
DBInstance:
Type: AWS::RDS::DBInstance
DeletionPolicy: Snapshot
UpdateReplacePolicy: Snapshot
Properties:
DBInstanceIdentifier: !Sub "${AWS::StackName}-mysql"
DBInstanceClass: db.t3.medium
Engine: mysql
EngineVersion: '8.0'
MasterUsername: !Ref MasterUsername
MasterUserPassword: !Ref MasterUserPassword
AllocatedStorage: 50
StorageType: gp3
StorageEncrypted: true
KmsKeyId: !Ref KmsKeyId
DBSubnetGroupName: !Ref DBSubnetGroup
VPCSecurityGroups: [!Ref DBSecurityGroup]
MultiAZ: !If [IsProduction, true, false]
BackupRetentionPeriod: !If [IsProduction, 35, 7]
DeletionProtection: !If [IsProduction, true, false]
EnablePerformanceInsights: !If [IsProduction, true, false]
PerformanceInsightsRetentionPeriod: !If [IsProduction, 731, 7]
KmsKeyId:
Type: AWS::KMS::Key
Condition: IsProduction
Properties:
Description: KMS key for RDS encryption
EnableKeyRotation: true
KeyPolicy:
Version: '2012-10-17'
Statement:
- Sid: Enable IAM User Permissions
Effect: Allow
Principal:
AWS: !Sub arn:aws:iam::${AWS::AccountId}:root
Action: kms:*
Resource: '*'
Outputs:
DBEndpoint:
Description: Database endpoint
Value: !GetAtt DBInstance.Endpoint.Address
Export:
Name: !Sub ${AWS::StackName}-DBEndpoint
DBPort:
Description: Database port
Value: !GetAtt DBInstance.Endpoint.Port
Export:
Name: !Sub ${AWS::StackName}-DBPort
See examples.md for additional examples including Aurora clusters, read replicas, and multi-region setups.
References
Core Configuration
- template-structure.md — Template sections, parameters, mappings, conditions, outputs, cross-stack references
- database-components.md — DB instances, clusters, parameter groups, subnet groups, Aurora configurations
- security-secrets.md — Security groups, encryption, Secrets Manager, IAM authentication
- high-availability.md — Multi-AZ, read replicas, Aurora auto-scaling, disaster recovery
Operational Guides
- operational-practices.md — Stack policies, termination protection, drift detection, change sets, monitoring
- constraints.md — Resource limits, operational constraints, security constraints, cost considerations
Additional Resources
- examples.md — Complete production-ready examples
- reference.md — CloudFormation RDS resource reference
Constraints and Warnings
Resource Limits
- Maximum storage size varies by engine (up to 64 TB for MySQL/PostgreSQL)
- Maximum 500 resources per CloudFormation stack
- Parameter group limits vary by account/region
Cost Considerations
- Multi-AZ deployments cost approximately double single-AZ
- Provisioned IOPS (io1) significantly increases costs
- Backup storage beyond free tier incurs monthly costs
- Manual snapshots incur storage costs even after instance deletion
Security Constraints
- Master password cannot be retrieved after creation
- Encryption at rest cannot be disabled once enabled
- RDS instances must be in VPC (public access not recommended)
- Security group rules must restrict access to application tier
Operational Constraints
- Certain modifications (engine version, storage type) require instance replacement with downtime
- Maintenance windows may cause brief service interruptions
- Read replicas may lag behind primary by seconds to minutes
- Not all database engines available in all regions
See constraints.md for complete constraints, troubleshooting guides, and performance considerations.
AWS CloudFormation S3 Patterns
Provides S3 bucket configurations, policies, versioning, lifecycle rules, and CloudFormation template structure best practices for production-ready infrastructure.
When to Use
- Creating S3 buckets with custom configurations
- Implementing bucket policies for access control
- Configuring S3 versioning for data protection
- Setting up lifecycle rules for data management
- Creating Outputs for cross-stack references
- Using Parameters with AWS-specific types
- Organizing templates with Mappings and Conditions
Overview
S3 bucket configurations, policies, versioning, lifecycle rules, and CloudFormation template structure for production-ready infrastructure.
Instructions
- Define Bucket Resources: Create
AWS::S3::Bucketwith versioning, encryption, PublicAccessBlock - Configure Bucket Policy: Set up IAM policies for access control
- Set Up Lifecycle Rules: Define transitions and expiration policies
- Configure CORS: Allow cross-origin requests if needed
- Add Outputs: Export bucket names/ARNs for cross-stack references
Validate before deploy:
aws cloudformation validate-template --template-body file://template.yaml
Deploy with rollback on failure:
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-s3-stack \
--capabilities CAPABILITY_IAM
If deployment fails, CloudFormation automatically rolls back. Check failures with:
aws cloudformation describe-stack-events --stack-name my-s3-stack
Quick Reference
| Resource Type | Purpose |
|---|---|
AWS::S3::Bucket | Create S3 bucket |
AWS::S3::BucketPolicy | Set bucket-level policies |
AWS::S3::BucketReplication | Cross-region replication |
| Parameters | Input values for customization |
| Mappings | Static configuration tables |
| Conditions | Conditional resource creation |
| Outputs | Return values for cross-stack references |
Examples
Basic S3 Bucket
Resources:
DataBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: my-data-bucket
Bucket with Versioning and Encryption
DataBucket:
Type: AWS::S3::Bucket
Properties:
BucketName: !Sub "${AWS::StackName}-data"
VersioningConfiguration:
Status: Enabled
BucketEncryption:
ServerSideEncryptionConfiguration:
- ServerSideEncryptionByDefault:
SSEAlgorithm: AES256
PublicAccessBlockConfiguration:
BlockPublicAcls: true
BlockPublicPolicy: true
Lifecycle Rule
DataBucket:
Type: AWS::S3::Bucket
Properties:
LifecycleConfiguration:
Rules:
- Id: ArchiveOldData
Status: Enabled
Transitions:
- StorageClass: GLACIER
TransitionInDays: 365
Bucket Policy
BucketPolicy:
Type: AWS::S3::BucketPolicy
Properties:
Bucket: !Ref DataBucket
PolicyDocument:
Statement:
- Effect: Allow
Principal:
AWS: !Ref RoleArn
Action:
- s3:GetObject
Resource: !Sub "${DataBucket.Arn}/*"
See references/complete-examples.md for more complete examples including CORS, static websites, replication, and production-ready configurations.
Template Structure
Template Sections
AWSTemplateFormatVersion: 2010-09-09
Description: Template description
Mappings: {} # Static configuration tables
Metadata: {} # Additional information
Parameters: {} # Input values
Conditions: {} # Conditional creation
Transform: {} # Macro processing
Resources: {} # AWS resources (REQUIRED)
Outputs: {} # Return values
Parameters
Parameters:
BucketName:
Type: String
Description: S3 bucket name
Default: my-bucket
MinLength: 3
MaxLength: 63
AllowedPattern: '^[a-z0-9-]+$'
Conditions
Conditions:
IsProduction: !Equals [!Ref Environment, prod]
ShouldEnableVersioning: !Equals [!Ref EnableVersioning, 'true']
Resources:
DataBucket:
Type: AWS::S3::Bucket
Properties:
VersioningConfiguration:
Status: !If [ShouldEnableVersioning, Enabled, Suspended]
Outputs
Outputs:
BucketName:
Description: Name of the S3 bucket
Value: !Ref DataBucket
Export:
Name: !Sub '${AWS::StackName}-BucketName'
See references/advanced-configuration.md for detailed Mappings, Conditions, Parameters, and cross-stack references.
Best Practices
- Public Access Block: Always enable for non-static website buckets
- Versioning: Enable for critical data to prevent accidental deletion
- Bucket Policies: Use instead of ACLs for access control
- Lifecycle Rules: Implement cost optimization with tiering
- Encryption: Enable default encryption (SSE-KMS or AES256)
- Tags: Tag all resources for organization and cost allocation
- Outputs: Export bucket names/ARNs for cross-stack references
- Parameters: Use parameters for reusability across environments
Common Troubleshooting
Bucket already exists: Use unique bucket names with CloudFormation stack name Access denied: Verify bucket policy and IAM permissions Versioning conflicts: Cannot suspend versioning once objects exist Lifecycle not working: Check rule status and prefix filters Cross-stack references: Ensure outputs are exported before importing
Related Skills
- aws-cloudformation-security - Security best practices for S3
- aws-cloudformation-lambda - Lambda triggers for S3 events
- aws-cloudformation-iam - IAM roles for S3 access
References
Complete Examples
- references/complete-examples.md - Basic buckets, versioning, lifecycle, CORS, policies, production stacks, event notifications, static websites, replication
Advanced Configuration
- references/advanced-configuration.md - Parameters, Mappings, Conditions, Outputs, Metadata, DeletionPolicy, DependsOn, Transform
Constraints and Warnings
- Bucket names: Must be globally unique (across all AWS accounts)
- Versioning: Cannot be suspended once objects exist in bucket
- Lifecycle rules: Minimum 1 day for expiration, 0 days for transitions
- Bucket policies: Limited to 20 KB in size
- Public access: Blocked by default; requires explicit configuration
- CORS: Limited to 100 rules per bucket
- Replication: Versioning must be enabled on both source and destination
- Encryption: KMS keys must be in same region as bucket
- Tags: Maximum 50 tags per resource
- Stack limits: CloudFormation limits resources per stack (200 default)
AWS CloudFormation Security Infrastructure
Overview
Create production-ready security infrastructure using AWS CloudFormation templates. This skill covers KMS encryption, Secrets Manager, IAM security with least privilege, VPC security configurations, ACM certificates, parameter security, secure outputs, cross-stack references, CloudWatch Logs encryption, defense in depth strategies, and security best practices.
When to Use
- Implementing KMS encryption at rest and in transit
- Managing secrets with Secrets Manager and automatic rotation
- Applying IAM least privilege policies and permission boundaries
- Securing VPC with security groups, NACLs, and VPC endpoints
- Managing TLS/SSL certificates with ACM
- Encrypting CloudWatch Logs and S3 buckets
- Creating secure cross-stack references and outputs
Instructions
Follow these steps to create security infrastructure with CloudFormation:
1. Define KMS Encryption Keys
Create customer-managed keys for encryption:
Resources:
EncryptionKey:
Type: AWS::KMS::Key
Properties:
Description: Customer-managed key for data encryption
KeyPolicy:
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action:
- kms:Decrypt
- kms:GenerateDataKey
Resource: "*"
- Effect: Allow
Principal:
AWS: !Sub "arn:aws:iam::${AWS::AccountId}:root"
Action:
- kms:*
Resource: "*"
KeyAlias:
Type: AWS::KMS::Alias
Properties:
AliasName: !Sub "${AWS::StackName}/encryption-key"
TargetKeyId: !Ref EncryptionKey
Validate: aws kms get-key-policy --key-id <key-id> --output text
2. Manage Secrets with Secrets Manager
Store and retrieve sensitive data securely:
Resources:
DatabaseSecret:
Type: AWS::SecretsManager::Secret
Properties:
Name: !Sub "${AWS::StackName}/database"
Description: Database credentials
SecretString: !Sub |
{
"username": "admin",
"password": "${DatabasePassword}",
"engine": "mysql",
"host": "${DatabaseEndpoint}",
"port": 3306
}
KmsKeyId: !Ref EncryptionKey
SecretRotationSchedule:
Type: AWS::SecretsManager::RotationSchedule
Properties:
SecretId: !Ref DatabaseSecret
RotationLambdaARN: !Ref RotationLambda.Arn
RotationRules:
AutomaticallyAfterDays: 30
Validate: aws secretsmanager describe-secret --secret-id <secret-name>
3. Apply IAM Least Privilege
Create roles and policies with minimal required permissions:
Resources:
ExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Policies:
- PolicyName: SpecificPermissions
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- s3:GetObject
Resource: !Sub "${DataBucket.Arn}/*"
Validate: aws iam simulate-principal-policy --policy-source-arn <role-arn> --action-names s3:GetObject --resource-arns <bucket-arn>
4. Secure VPC Configuration
Implement network security with security groups and NACLs:
Resources:
ApplicationSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Application security group
VpcId: !Ref VPC
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 443
ToPort: 443
SourceSecurityGroupId: !Ref LoadBalancerSecurityGroup
SecurityGroupEgress:
- IpProtocol: -1
CidrIp: 0.0.0.0/0
ApplicationNACL:
Type: AWS::EC2::NetworkAcl
Properties:
VpcId: !Ref VPC
NACLEntry:
Type: AWS::EC2::NetworkAclEntry
Properties:
NetworkAclId: !Ref ApplicationNACL
RuleNumber: 100
Protocol: "6"
RuleAction: allow
Egress: false
CidrBlock: 0.0.0.0/0
PortRange:
From: 443
To: 443
Validate: aws ec2 describe-security-groups --group-ids <sg-id> --query 'SecurityGroups[0].IpPermissions'
5. Request ACM Certificates
Manage TLS/SSL certificates for secure communication:
Resources:
Certificate:
Type: AWS::ACM::Certificate
Properties:
DomainName: !Ref DomainName
SubjectAlternativeNames:
- !Sub "www.${DomainName}"
- !Sub "api.${DomainName}"
DomainValidationOptions:
- DomainName: !Ref DomainName
ValidationDomain: !Ref DomainName
Tags:
- Key: Environment
Value: !Ref Environment
# DNS validation record
DnsValidationRecord:
Type: AWS::Route53::RecordSet
Properties:
HostedZoneName: !Ref HostedZone
Name: !Sub "_${DomainName}."
Type: CNAME
TTL: 300
ResourceRecords:
- !Ref Certificate
Validate: aws acm describe-certificate --certificate-arn <arn> --query 'Certificate.Status'
6. Implement Secure Parameters
Use SecureString for sensitive parameter values:
Resources:
DatabasePasswordParameter:
Type: AWS::SSM::Parameter
Properties:
Name: !Sub "/${AWS::StackName}/database/password"
Type: SecureString
Value: !Ref DatabasePassword
Description: Database master password
KmsKeyId: !Ref EncryptionKey
# Reference in other resources
DatabaseInstance:
Type: AWS::RDS::DBInstance
Properties:
MasterUsername: admin
MasterUserPassword: !Ref DatabasePasswordParameter
Validate: aws ssm get-parameter --name <param-name> --with-decryption --query 'Parameter.Type'
7. Create Secure Outputs
Export only non-sensitive values from stacks:
Outputs:
# Safe to export
KMSKeyArn:
Description: KMS Key ARN for encryption
Value: !GetAtt EncryptionKey.Arn
Export:
Name: !Sub "${AWS::StackName}-KMSKeyArn"
SecretArn:
Description: Secret ARN (not the secret value)
Value: !Ref DatabaseSecret
Export:
Name: !Sub "${AWS::StackName}-SecretArn"
# DO NOT export sensitive data
# Incorrect:
# SecretValue:
# Value: !GetAtt DatabaseSecret.SecretString
Validate: aws cloudformation list-exports --query "Exports[?Name=='<stack-name>-KMSKeyArn']"
8. Encrypt CloudWatch Logs
Enable encryption for log groups:
Resources:
EncryptedLogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/applications/${ApplicationName}"
RetentionInDays: 30
KmsKeyId: !Ref EncryptionKey
Validate: aws logs describe-log-groups --log-group-name-prefix <prefix> --query 'logGroups[0].kmsKeyId'
Best Practices
- KMS: Use separate keys per data classification; enable annual key rotation; use customer-managed keys for compliance
- Secrets: Rotate automatically (30 days for databases); never store secrets in plain text; use IAM policies for access control
- IAM: Apply least privilege; use roles not access keys; enable MFA; implement permission boundaries
- Network: Prefer security groups over NACLs; use VPC endpoints; restrict by specific CIDR ranges
- Certificates: Use ACM for automatic renewal; DNS validation is faster than email
- Encryption: Encrypt at rest and in transit; TLS 1.2+ required; use SSE-KMS for S3
Examples
Complete KMS and Secrets Stack
Resources:
# KMS Key with proper policy
AppKey:
Type: AWS::KMS::Key
Properties:
KeyPolicy:
Statement:
- Effect: Allow
Principal:
AWS: !Sub "arn:aws:iam::${AWS::AccountId}:root"
Action: kms:*
Resource: "*"
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action:
- kms:Decrypt
- kms:GenerateDataKey
Resource: "*"
# Secrets Manager with rotation
DbSecret:
Type: AWS::SecretsManager::Secret
Properties:
SecretString: !Sub '{"password":"${DbPassword}"}'
KmsKeyId: !Ref AppKey
RotationRules:
AutomaticallyAfterDays: 30
IAM Least Privilege Role
Resources:
LambdaRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
Policies:
- PolicyName: AccessPolicy
PolicyDocument:
Statement:
- Effect: Allow
Action: s3:GetObject
Resource: !Sub "${Bucket.Arn}/*"
For comprehensive examples with VPC security groups, ACM certificates, and complete encrypted infrastructure stacks, see examples.md.
Constraints and Warnings
Resource Limits
- Security groups: max 60 inbound + 60 outbound rules
- NACLs: max 20 inbound + 20 outbound rules per subnet
- VPCs: max 5 per region (soft limit)
- Key rotation: annual for KMS customer-managed keys
Security Constraints
- NACLs are stateless: return traffic must be explicitly allowed
- Default security groups cannot be deleted
- Security group references cannot span VPC peering (use CIDR)
- Cross-account access requires both IAM and resource policies
Operational Warnings
- Secrets rotation requires Lambda function with proper IAM permissions
- KMS key deletion requires pending window (7-30 days)
- ACM certificates need DNS validation before issuance
- VPC CIDR blocks cannot overlap with peered VPCs
For detailed constraints including cost considerations and quota management, see constraints.md.
References
For detailed implementation guidance, see:
- examples.md - Complete KMS stacks, Secrets Manager with rotation, IAM least privilege roles, VPC security groups, ACM certificates, and encrypted infrastructure
- constraints.md - Resource limits, security constraints, operational constraints, network constraints, cost considerations, and access control constraints
AWS CloudFormation Task ECS Deploy with GitHub Actions
Comprehensive skill for deploying ECS containers using GitHub Actions CI/CD pipelines with CloudFormation infrastructure management.
Overview
Deploy containerized applications to Amazon ECS using GitHub Actions workflows. This skill covers the complete deployment pipeline: authentication with AWS (OIDC recommended), building Docker images, pushing to Amazon ECR, updating task definitions, and deploying ECS services. Integrate with CloudFormation for infrastructure-as-code management and implement production-grade deployment strategies.
When to Use
- Deploying Docker containers to Amazon ECS with GitHub Actions
- Setting up CI/CD pipelines for ECS using CloudFormation
- Configuring AWS OIDC authentication for GitHub Actions
- Building Docker images and pushing to Amazon ECR
- Updating ECS task definitions dynamically in CI/CD
- Implementing blue/green or rolling deployments for ECS
- Managing CloudFormation stacks from GitHub Actions
Instructions
Follow these steps to set up ECS deployment with GitHub Actions:
- Configure AWS Authentication: Set up OIDC provider for GitHub Actions
- Create IAM Roles: Define roles for deployment actions
- Set Up ECR Repository: Create repository with image scanning
- Create ECS Cluster: Define cluster infrastructure
- Configure Task Definition: Set up task and container definitions
- Set Up ECS Service: Configure service with deployment strategy
- Create GitHub Workflow: Define CI/CD pipeline steps
- Configure Secrets: Store credentials securely in GitHub Secrets
Quick Start
Basic Deployment Workflow
name: Deploy to ECS
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
permissions:
id-token: write
contents: read
steps:
- uses: actions/checkout@v4
- name: Configure AWS credentials
uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: arn:aws:iam::123456789012:role/github-actions-ecs-role
aws-region: us-east-1
- name: Login to ECR
uses: aws-actions/amazon-ecr-login@v2
- name: Build and push image
env:
ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
ECR_REPOSITORY: my-app
IMAGE_TAG: ${{ github.sha }}
run: |
docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
- name: Verify image push
run: |
docker pull $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
echo "Image $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG verified"
- name: Update task definition
uses: aws-actions/amazon-ecs-render-task-definition@v1
id: render-task
with:
task-definition: task-definition.json
container-name: my-app
image: ${{ steps.login-ecr.outputs.registry }}/my-app:${{ github.sha }}
- name: Validate task definition
run: |
# Validate JSON syntax
cat ${{ steps.render-task.outputs.task-definition }} | jq empty && echo "Task definition JSON is valid"
# Verify container image matches expected
CONTAINER_IMAGE=$(cat ${{ steps.render-task.outputs.task-definition }} | jq -r '.containerDefinitions[0].image')
EXPECTED_IMAGE="${{ steps.login-ecr.outputs.registry }}/my-app:${{ github.sha }}"
if [ "$CONTAINER_IMAGE" = "$EXPECTED_IMAGE" ]; then
echo "Container image matches expected: $CONTAINER_IMAGE"
else
echo "ERROR: Container image mismatch. Expected: $EXPECTED_IMAGE, Got: $CONTAINER_IMAGE"
exit 1
fi
- name: Deploy to ECS
uses: aws-actions/amazon-ecs-deploy-task-definition@v1
with:
task-definition: ${{ steps.render-task.outputs.task-definition }}
service: my-service
cluster: my-cluster
wait-for-service-stability: true
See references/workflow-examples.md for complete workflow examples including multi-environment and blue/green deployments.
Examples
Multi-Environment Deployment
jobs:
deploy:
strategy:
matrix:
environment: [dev, staging, prod]
steps:
- uses: actions/checkout@v4
- name: Configure AWS credentials
uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: arn:aws:iam::${{ matrix.env_account }}:role/github-actions-ecs-role
aws-region: ${{ matrix.region }}
- name: Deploy to ${{ matrix.environment }}
run: |
ECR_REGISTRY=${{ env.ECR_REGISTRY }}
docker build -t $ECR_REGISTRY/my-app:${{ github.sha }} .
docker push $ECR_REGISTRY/my-app:${{ github.sha }}
Blue/Green Deployment with CodeDeploy
- name: Deploy with CodeDeploy
run: |
aws deploy create-deployment \
--application-name my-app \
--deployment-group-name ${{ matrix.environment }} \
--deployment-config-name CodeDeployDefault ECSAllAtOnce \
--revision "{\"revisionType\":\"AppSpecContent\",\"appSpecContent\":{\"content\":\"$(cat appspec.yml)\",\"filename\":\"appspec.yml\"}}"
aws deploy wait deployment-successful --deployment-id $(aws deploy list-deployments --application-name my-app --query 'deployments[0]' --output text)
See references/workflow-examples.md for additional patterns including ECR lifecycle policies, task definition templates, and CloudFormation stack updates.
Best Practices
Security
- Use OIDC authentication instead of long-lived IAM keys
- Implement least privilege IAM roles with specific permissions
- Enable ECR image scanning on push
- Use AWS Secrets Manager for sensitive data
- Encrypt ECR repositories with KMS
- VPC endpoints for ECR and ECS without internet gateway
- Security groups restrict access to minimum required
Performance
- Docker layer caching with GitHub Actions cache
- Multi-stage builds to minimize image size
- Parallel deployments across multiple environments
- Fargate Spot for cost savings on non-critical workloads
- CloudWatch Logs with appropriate retention policies
Cost Optimization
- ECR lifecycle policies to clean up old images
- Fargate Spot instances for development/testing
- Right-sized task CPU and memory
- Auto-scaling based on metrics
- Scheduled scaling for predictable traffic patterns
See references/best-practices.md for detailed security, performance, and cost optimization guidelines.
Common Troubleshooting
Authentication Failures
- Verify OIDC trust relationship matches GitHub organization/repository
- Check IAM role has proper permissions for ECR and ECS
- Ensure GitHub Actions repository has
id-token: writepermission
Deployment Failures
- Check CloudWatch Logs for application errors
- Verify task definition matches service requirements
- Ensure sufficient CPU/memory in Fargate cluster
- Review health check configuration
ECR Push Failures
- Verify repository exists and permissions are correct
- Check image tag format and registry URL
- Ensure Docker daemon is running in GitHub Actions runner
- Verify image size doesn't exceed ECR limits
CloudFormation Rollback
- Review stack events in AWS Console
- Check parameter values match resource constraints
- Verify IAM role has
cloudformation:UpdateStackpermission - Enable termination protection for production stacks
See references/best-practices.md for complete troubleshooting guide with debug commands.
Related Skills
- aws-cloudformation-ecs - Design and implement ECS cluster architecture
- aws-cloudformation-lambda - Deploy Lambda functions with GitHub Actions
- aws-cloudformation-security - Security best practices for ECS deployments
References
Complete Examples
- references/workflow-examples.md - Complete GitHub Actions workflows including basic deployment, multi-environment, blue/green, and CI/CD pipelines
Configuration
- references/authentication.md - OIDC provider setup, IAM roles, cross-account deployment, environment-specific roles
- references/ecr-and-task-definitions.md - ECR repository configuration, task definition management, multi-container setups
- references/deployment-strategies.md - Rolling and blue/green deployments, CloudFormation templates, stack updates
Best Practices
- references/best-practices.md - Security guidelines, performance optimization, cost optimization, monitoring, and complete troubleshooting guide
Constraints and Warnings
Resource Limits
- GitHub Actions Limits: Usage limits per account (minutes, storage)
- Workflow File Size: Cannot exceed 1 MB
- Job Matrix Limits: Limits on total matrix combinations
- Artifact Retention: Default 90-day retention
Authentication Constraints
- OIDC Tokens: Limited lifetime (typically 5 minutes)
- Role Session Duration: Maximum 12 hours
- Permission Scope: Least-privilege permissions required
- Cross-Account Access: Requires appropriate trust relationships
Operational Constraints
- Deployment Speed: CloudFormation deployments may take time
- Stack Locking: Cannot update while another deployment is in progress
- ECR Rate Limits: API rate limits may affect large deployments
- ECS Service Limits: Limits on tasks per service and services per cluster
Security Constraints
- Secret Management: Never store secrets in repository or workflow files
- OIDC Provider: Must be configured in AWS account before first use
- Repository Access: Workflow secrets are scoped to repository
- Token Security: Minimum required permissions only (contents: read, id-token: write)
Cost Considerations
- GitHub Actions: Minutes beyond free tier incur costs
- ECR Storage: Monthly storage costs for container images
- ECS/Fargate: Costs for vCPU and memory resources
- Data Transfer: Costs for data transfer between GitHub and AWS
AWS CloudFormation VPC Infrastructure
Overview
Build a VPC foundation with CloudFormation that stays readable, reusable, and safe to evolve. Provides a clear subnet and routing model with predictable connectivity for public and private workloads, plus outputs that downstream stacks can consume without duplicating network logic.
Use the references/ files for larger templates and extended service combinations.
When to Use
- Creating a new VPC stack for an application or shared platform
- Adding public and private subnets across one or more Availability Zones
- Wiring internet access, NAT egress, or private endpoints
- Exporting VPC, subnet, route table, and security-group-adjacent identifiers for other stacks
- Preparing reusable infrastructure for ECS, EKS, Lambda, EC2, or RDS stacks
Instructions
1. Start with the address plan
Before writing resources, define:
- VPC CIDR range
- Number of Availability Zones
- Public, private, and isolated subnet ranges
- Which workloads need internet ingress, NAT egress, or only private AWS service access
This prevents route-table sprawl and painful subnet replacement later.
2. Build the core network resources in layers
Create the stack in this order:
- VPC and subnets
- Internet Gateway for public ingress and egress
- NAT gateways if private subnets need outbound internet access
- Route tables and subnet associations
- Optional VPC endpoints for private access to AWS services
Keep each layer easy to inspect in the template and avoid mixing unrelated application resources into the same stack.
3. Parameterize only the environment-dependent values
Useful parameters include:
- Environment name
- VPC CIDR and subnet CIDRs
- Number of AZs or explicit subnet IDs in nested-stack scenarios
- Flags for optional endpoints or NAT layout
Do not parameterize every route or tag unless it meaningfully changes between environments.
4. Export only what consumers really need
Typical outputs:
- VPC ID
- Public, private, and isolated subnet IDs
- Route table IDs when downstream stacks must attach routes
- Security boundaries or prefix-list references only when another stack consumes them
Stable outputs make application stacks easier to compose and migrate.
5. Validate before deployment
Run these commands to validate the template and verify routing:
# Validate CloudFormation template syntax
aws cloudformation validate-template --template-body file://vpc.yaml
# Review change set before applying
aws cloudformation create-change-set \
--stack-name my-vpc \
--template-body file://vpc.yaml \
--change-set-type CREATE
# Verify route table associations
aws ec2 describe-route-tables \
--filters "Name=vpc-id,Values=<vpc-id>"
# Check subnet to route table mappings
aws ec2 describe-route-tables \
--filters "Name=association.subnet-id,Values=<subnet-id>"
# Verify internet gateway attachment
aws ec2 describe-internet-gateways \
--filters "Name=attachment.vpc-id,Values=<vpc-id>"
Examples
Example 1: Complete two-tier VPC with routing
This template creates a VPC with public and private subnets, internet gateway, NAT gateway, and properly configured route tables.
AWSTemplateFormatVersion: "2010-09-09"
Description: "Two-tier VPC with public and private subnets"
Resources:
# VPC
MainVpc:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.0.0.0/16
EnableDnsHostnames: true
EnableDnsSupport: true
Tags:
- Key: Name
Value: !Sub "${AWS::StackName}-main"
# Internet Gateway
InternetGateway:
Type: AWS::EC2::InternetGateway
Properties:
Tags:
- Key: Name
Value: !Sub "${AWS::StackName}-igw"
# Attach IGW to VPC
GatewayToInternet:
Type: AWS::EC2::VPCGatewayAttachment
Properties:
VpcId: !Ref MainVpc
InternetGatewayId: !Ref InternetGateway
# Public Subnet (AZ 1)
PublicSubnetA:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MainVpc
CidrBlock: 10.0.1.0/24
AvailabilityZone: !Select [0, !GetAZs ""]
MapPublicIpOnLaunch: true
Tags:
- Key: Name
Value: !Sub "${AWS::StackName}-public-a"
# Private Subnet (AZ 1)
PrivateSubnetA:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MainVpc
CidrBlock: 10.0.11.0/24
AvailabilityZone: !Select [0, !GetAZs ""]
Tags:
- Key: Name
Value: !Sub "${AWS::StackName}-private-a"
# Elastic IP for NAT Gateway
NatEip:
Type: AWS::EC2::EIP
DependsOn: GatewayToInternet
Properties:
Domain: vpc
# NAT Gateway
NatGateway:
Type: AWS::EC2::NatGateway
Properties:
SubnetId: !Ref PublicSubnetA
AllocationId: !GetAtt NatEip.AllocationId
# Public Route Table
PublicRouteTable:
Type: AWS::EC2::RouteTable
Properties:
VpcId: !Ref MainVpc
Tags:
- Key: Name
Value: !Sub "${AWS::StackName}-public-rt"
# Default route to IGW
PublicDefaultRoute:
Type: AWS::EC2::Route
DependsOn: GatewayToInternet
Properties:
RouteTableId: !Ref PublicRouteTable
DestinationCidrBlock: 0.0.0.0/0
GatewayId: !Ref InternetGateway
# Associate public subnet
PublicSubnetARouteTableAssociation:
Type: AWS::EC2::SubnetRouteTableAssociation
Properties:
SubnetId: !Ref PublicSubnetA
RouteTableId: !Ref PublicRouteTable
# Private Route Table
PrivateRouteTable:
Type: AWS::EC2::RouteTable
Properties:
VpcId: !Ref MainVpc
Tags:
- Key: Name
Value: !Sub "${AWS::StackName}-private-rt"
# Default route via NAT Gateway
PrivateDefaultRoute:
Type: AWS::EC2::Route
Properties:
RouteTableId: !Ref PrivateRouteTable
DestinationCidrBlock: 0.0.0.0/0
NatGatewayId: !Ref NatGateway
# Associate private subnet
PrivateSubnetARouteTableAssociation:
Type: AWS::EC2::SubnetRouteTableAssociation
Properties:
SubnetId: !Ref PrivateSubnetA
RouteTableId: !Ref PrivateRouteTable
Outputs:
VpcId:
Description: VPC ID
Value: !Ref MainVpc
Export:
Name: !Sub "${AWS::StackName}-VpcId"
PublicSubnetA:
Description: Public subnet AZ1
Value: !Ref PublicSubnetA
Export:
Name: !Sub "${AWS::StackName}-PublicSubnetA"
PrivateSubnetA:
Description: Private subnet AZ1
Value: !Ref PrivateSubnetA
Export:
Name: !Sub "${AWS::StackName}-PrivateSubnetA"
PublicRouteTableId:
Description: Public route table ID
Value: !Ref PublicRouteTable
Export:
Name: !Sub "${AWS::StackName}-PublicRouteTableId"
PrivateRouteTableId:
Description: Private route table ID
Value: !Ref PrivateRouteTable
Export:
Name: !Sub "${AWS::StackName}-PrivateRouteTableId"
Example 2: VPC endpoint for private S3 access
Resources:
# S3 VPC Endpoint
S3Endpoint:
Type: AWS::EC2::VPCEndpoint
Properties:
VpcId: !Ref MainVpc
ServiceName: !Sub "com.amazonaws.${AWS::Region}.s3"
RouteTableIds:
- !Ref PrivateRouteTable
VpcEndpointType: Gateway
Best Practices
- Keep public, private, and isolated subnet purposes explicit in names and tags
- Prefer one NAT gateway per AZ for resilient production environments when budget allows
- Use VPC endpoints to reduce unnecessary NAT traffic for AWS service access
- Export VPC and subnet identifiers from the network stack instead of recreating network assumptions elsewhere
- Review network changes with dependency stacks because route and subnet changes can have broad blast radius
- Keep the root skill focused and move larger networking variants to
references/examples.md
Constraints and Warnings
- NAT gateways incur hourly costs and data transfer charges—consider VPC endpoints for AWS service access
- CIDR overlap blocks peering, transit, and future network expansion
- Route-table or subnet replacements can interrupt traffic even when the template is valid
- Endpoint quotas, AZ availability, and service-specific subnet requirements vary by region
- Hardcoding Availability Zones can reduce portability across accounts and regions
References
references/examples.mdreferences/reference.md
AWS CLI Beast Mode
Overview
Advanced AWS CLI patterns for speed, precision, and security-first automation. Covers JMESPath queries, bulk operations, waiters, cross-account access, and destructive operation safety.
When to Use
- Bulk operations across thousands of AWS resources
- Advanced JMESPath filtering and output transformation
- Automated scripts for AWS routines
- Multi-profile and multi-region management
- Security auditing and compliance checks
- CLI-driven infrastructure-as-code workflows
Instructions
Step 1: Categorize the Request
| Category | Services | Commands |
|---|---|---|
| Compute | EC2, Lambda | describe-instances, invoke, publish-version |
| Storage | S3 | sync, cp, mb, rb, presign |
| Database | DynamoDB, RDS | query, scan, batch-write-item |
| Networking | VPC, Route53 | describe-vpcs, describe-security-groups |
| Security | IAM | simulate-principal-policy, get-policy-version |
| Observability | CloudWatch | get-metric-statistics, filter-log-events |
Step 2: Apply Beast Mode Principles
- Dry-run first: Always validate with
--dryrunor--dry-run - Query server-side: Use
--querywith JMESPath to filter before transfer - Batch intelligently: Paginate with
--max-resultsand parallelize with xargs - Wait properly: Use built-in waiters or exponential backoff polling
- Switch contexts: Use
--profileand--regionfor multi-account operations
Step 3: Validate Destructive Operations
MANDATORY for any destructive operation:
# S3 sync with delete - MUST dry-run first
aws s3 sync s3://source/ s3://dest/ --delete --dryrun
# Review output, then remove --dryrun only if satisfied
# Bulk EC2 stop - validate targets first
aws ec2 describe-instances \
--filters "Name=tag:Environment,Values=development" \
--query 'Reservations[].Instances[?State.Name==`running`].InstanceId' \
--output text
# Confirm list, then pipe to stop command
# IAM policy attachment - simulate first
aws iam simulate-principal-policy \
--policy-source-arn arn:aws:iam::123456789012:user/myuser \
--action-names s3:DeleteObject \
--resource-arns arn:aws:s3:::my-bucket/*
Step 4: Reference Detailed Guides
compute-mastery.md- EC2, Lambda, Spot Fleets, ASGdata-ops-beast.md- S3 multipart, DynamoDB batch, RDS snapshotsnetworking-security-hardened.md- VPC Flow Logs, IAM policies, security groupsautomation-patterns.md- Shell aliases, JMESPath templates, CI/CD integration
Examples
Example 1: Bulk EC2 Stop
"Stop all development instances"
# 1. Dry-run: identify targets
aws ec2 describe-instances \
--filters "Name=tag:Environment,Values=development" \
"Name=instance-state-name,Values=running" \
--query 'Reservations[].Instances[].InstanceId' \
--output text
# 2. Confirm IDs, then execute
aws ec2 describe-instances \
--filters "Name=tag:Environment,Values=development" \
"Name=instance-state-name,Values=running" \
--query 'Reservations[].Instances[].InstanceId' \
--output text | xargs aws ec2 stop-instances --instance-ids
Example 2: S3 Migration with Encryption
"Migrate data between buckets with SSE"
# 1. Dry-run migration
aws s3 sync s3://source-bucket/ s3://dest-bucket/ \
--sse AES256 \
--storage-class GLACIER \
--exclude "*.tmp" \
--dryrun
# 2. Enable versioning on destination
aws s3api put-bucket-versioning \
--bucket dest-bucket \
--versioning-configuration Status=Enabled
# 3. Execute after review
aws s3 sync s3://source-bucket/ s3://dest-bucket/ \
--sse AES256 \
--storage-class GLACIER \
--exclude "*.tmp"
Example 3: IAM Security Audit
"Find overprivileged IAM users"
aws iam list-users --query 'Users[].UserName' --output text | \
while read user; do
echo "Checking $user..."
aws iam simulate-principal-policy \
--policy-source-arn "arn:aws:iam::123456789012:user/$user" \
--action-names DeleteItem,DeleteTable,DeleteFunction \
--resource-arns "*" \
--query 'EvaluationResults[?EvalDecision==`allowed`]'
done
Example 4: Multi-Region Lambda Deployment
"Deploy Lambda to all regions"
for region in us-east-1 us-west-2 eu-west-1; do
echo "Deploying to $region..."
aws lambda update-function-code \
--function-name my-function \
--zip-file fileb://function.zip \
--region $region \
--publish
aws lambda wait function-active \
--function-name my-function \
--region $region
done
Example 5: JMESPath Advanced Filtering
"Get running instances with specific tags as table"
aws ec2 describe-instances \
--query 'Reservations[].Instances[?State.Name==`running`].[InstanceId,Tags[?Key==`Name`].Value[0]|[0],PrivateIpAddress]' \
--output table
Best Practices
- Use
--output jsonfor programmatic processing - Filter with JMESPath server-side before transfer
- Implement retry logic with exponential backoff
- Use waiters instead of manual polling loops
- Tag all resources for cost allocation and automation
- Separate dev/staging/prod with AWS profiles
- Enable CloudTrail for audit compliance
- Validate IAM policies with simulate-principal-policy before attachment
- Use --dry-run on every state-modifying operation
- Enable MFA for security-sensitive operations
Constraints and Warnings
Rate Limiting
- AWS API throttling applies; use
--max-throttleand exponential backoff - Check
aws service-quotasfor current limits
Pagination
- Default page size is variable; use
--max-resultsfor consistency - Use
--no-paginatewith jq for full dataset processing
Destructive Operations
- S3 sync --delete: Irreversibly removes files not in source
- EC2 terminate-instances: Cannot be undone; validate instance IDs first
- IAM detach/policy: May break existing access; simulate before applying
- RDS delete-db-instance: Snapshots do not protect all scenarios; verify retention
Security
- Never commit AWS credentials; use
aws configureor environment variables - Rotate access keys regularly with
aws iam create-access-key - Use least-privilege: simulate before granting permissions
AWS Cost Optimization
Overview
Guide a structured AWS cost review covering right-sizing, elasticity, pricing models, storage optimization, and continuous monitoring. References AWS native tools (Cost Explorer, Budgets, Compute Optimizer, Trusted Advisor, Cost Anomaly Detection) and delivers twelve prioritized best practices organized under five optimization pillars. All examples use the AWS CLI.
When to Use
- Optimizing AWS costs or reviewing AWS spending
- Finding unused or under-utilized AWS resources
- Implementing FinOps practices for cloud cost governance
- Reducing EC2, EBS, S3, or load balancer bills
- Choosing between On-Demand, Spot, Reserved Instances, and Savings Plans
- Configuring AWS Budgets, Cost Explorer, or Cost Anomaly Detection
- Performing an AWS Well-Architected Framework cost pillar review
- Cleaning up orphaned EBS snapshots or unused volumes
- Automating start/stop schedules for non-production workloads
Trigger: "Optimize my AWS costs", "Review AWS spending", "Find unused AWS resources", "Help me with FinOps", "Reduce my EC2 bill", "Clean up unused EBS volumes", "Set up AWS Budgets"
Instructions
Five Optimization Pillars
Work through each pillar in order during a cost review.
Pillar 1 — Right-Size
Match provisioned resources to actual workload needs.
- Pull 14-day average CPU/memory metrics from CloudWatch for every EC2 instance
- Cross-reference with AWS Compute Optimizer recommendations
- Flag instances where peak utilization stays below 40%
- Recommend downsizing to the next smaller instance family/size
- For RDS, check read/write IOPS vs. provisioned capacity
Pillar 2 — Increase Elasticity
Schedule instance stop/start and leverage Auto Scaling Groups.
- Identify non-production instances running 24/7 (dev, staging, QA)
- Propose stop/start schedules using AWS Instance Scheduler or EventBridge rules
- Review Auto Scaling Group policies for over-provisioned min/desired counts
- Recommend target-tracking scaling policies tied to actual demand metrics
- Consider Lambda or Fargate for bursty, event-driven workloads
Pillar 3 — Leverage the Right Pricing Model
Choose the optimal mix of On-Demand, Spot, Reserved Instances, and Savings Plans.
- Analyze steady-state baseline using Cost Explorer RI Coverage and Savings Plans Coverage reports
- Recommend Compute Savings Plans for consistent baseline compute
- Suggest Spot Instances for fault-tolerant, stateless workloads (batch, CI/CD runners)
- Evaluate existing Reserved Instances for utilization; resell unused RIs on the RI Marketplace
- Use the AWS Pricing Calculator to model total cost under each pricing option
Pillar 4 — Optimize Storage
Eliminate waste in EBS, S3, and snapshots.
- List unattached EBS volumes (
availablestate) and recommend deletion after backup review - Identify orphaned EBS snapshots no longer linked to an active AMI or volume
- Review S3 bucket metrics; recommend Intelligent-Tiering or lifecycle rules for infrequent access data
- Enable Amazon Data Lifecycle Manager (DLM) for automated snapshot retention
- Check for gp2 volumes that should be migrated to gp3 for cost and performance gains
Pillar 5 — Measure, Monitor, and Improve
Establish continuous cost governance.
- Implement a cost allocation tagging strategy (e.g.,
Environment,Team,Project,CostCenter) - Configure AWS Budgets with threshold alerts (50%, 80%, 100%, forecasted)
- Enable AWS Cost Anomaly Detection for automatic spend anomaly alerts
- Set up a monthly Cost Explorer saved report for leadership review
- Create a Trusted Advisor check schedule for cost optimization recommendations
Review Process
Follow this structured flow when the user asks for a cost review:
- Scope — Ask which AWS accounts, regions, and services to review
- Data Gathering — Pull Cost Explorer data for the last 30–90 days; identify top-5 cost drivers
- Pillar Walk-Through — Evaluate each of the five pillars in order
- Checklist — Present the twelve best practices as a scored checklist (done / not done / partial)
- Quick Wins — Highlight the three highest-impact, lowest-effort actions
- Roadmap — Propose a 30/60/90-day optimization plan with estimated savings
Examples
Example 1 — List Unattached EBS Volumes
User: "Find unused EBS volumes in my account."
CLI commands to include in the response:
# List all EBS volumes in available (unattached) state
aws ec2 describe-volumes \
--filters Name=status,Values=available \
--query 'Volumes[*].{VolumeId:VolumeId,Size:Size,Type:VolumeType,Zone:AvailabilityZone,CreateTime:CreateTime}' \
--output table
# Get monthly cost estimate for unused volumes (approx $0.08/GB/mo for gp3)
aws ec2 describe-volumes \
--filters Name=status,Values=available \
--query 'length(Volumes[*].[VolumeId,Size])' \
--output text
# List orphaned snapshots (not linked to any AMI)
aws ec2 describe-snapshots \
--owner-ids self \
--query 'Snapshots[?!contains(Description, `ami-`)].[SnapshotId,VolumeId,StartTime,Size]'
Example 2 — EC2 Right-Sizing with Compute Optimizer
User: "How can I reduce my EC2 bill?"
CLI commands to include in the response:
# Get Compute Optimizer right-sizing recommendations for EC2
aws compute-optimizer get-ec2-instance-recommendations \
--query 'instanceRecommendations[*].{InstanceArn:instanceArn,CurrentInstanceType:currentInstanceType,RecommendedInstanceType:recommendations[0].instanceType,MonthlySaving:recommendations[0].estimatedMonthlySavings.value}' \
--output table
# Pull average CPU utilization for an instance over 14 days
aws cloudwatch get-metric-statistics \
--namespace AWS/EC2 \
--metric-name CPUUtilization \
--dimensions Name=InstanceId,Value=i-1234567890abcdef0 \
--start-time 2026-03-09T00:00:00Z \
--end-time 2026-03-23T00:00:00Z \
--period 86400 \
--statistics Average \
--output table
# List all running instances by type for baseline analysis
aws ec2 describe-instances \
--filters Name=instance-state-name,Values=running \
--query 'Reservations[].Instances[].[InstanceId,InstanceType,Tags[?Key==`Name`].Value|[0],State.Name]' \
--output table
Example 3 — Cost Explorer and Budgets Setup
User: "Set up AWS Budgets and monitor my spend."
CLI commands to include in the response:
# Create a monthly cost budget with alert thresholds at 50%, 80%, 100%
aws budgets create-budget \
--account-id 123456789012 \
--budget '{
"BudgetName": "Monthly-Cost-Budget",
"BudgetLimit": {"Amount": "5000", "Unit": "USD"},
"TimeUnit": "MONTHLY",
"BudgetType": "COST"
}' \
--notifications-with-subscribers '[{"Notification": {"ComparisonOperator": "GREATER_THAN", "NotificationType": "ACTUAL", "Threshold": 80},"Subscribers": [{"Address": "email@example.com","SubscriptionType": "EMAIL"}]}]'
# Get top-5 cost drivers from Cost Explorer (last 30 days)
aws ce get-cost-and-usage \
--time-period Start=2026-02-23,End=2026-03-23 \
--granularity MONTHLY \
--metrics "BlendedCost" "UnblendedCost" \
--group-by Type=DIMENSION,Key=SERVICE \
--query 'ResultsByTime[0].Groups[*].{Service:Keys[0],BlendedCost:Metrics.BlendedCost.Amount}' \
--output table
# Enable Cost Anomaly Detection alert
aws ce create-anomaly-monitor \
--monitor-name "Daily-Cost-Anomaly" \
--monitor-arn "arn:aws:ce::123456789012:anomaly-monitor/cost-explorer"
Example 4 — S3 Lifecycle and Storage Tiering
User: "Optimize my S3 storage costs."
CLI commands to include in the response:
# List S3 buckets with size and storage class distribution
aws s3api list-buckets --query 'Buckets[*].Name'
aws s3api get-bucket-storage-type-aggregation --bucket YOUR-BUCKET-NAME
# Apply S3 Intelligent-Tiering lifecycle rule for objects older than 90 days
aws s3api put-bucket-lifecycle-configuration \
--bucket YOUR-BUCKET-NAME \
--lifecycle-configuration '{
"Rules": [{
"ID": "MoveToIntelligentTiering",
"Status": "Enabled",
"Filter": {},
"Transitions": [
{"Days": 30, "StorageClass": "INTELLIGENT_TIERING"},
{"Days": 90, "StorageClass": "GLACIER_IR"}
]
}]
}'
Example 5 — Spot Instances and Savings Plans
User: "Should I use Spot Instances or Savings Plans?"
CLI commands to include in the response:
# Check current RI and Savings Plans coverage
aws ce get-savings-plans-coverage \
--time-period Start=2026-01-01,End=2026-03-23 \
--granularity MONTHLY
# List available Spot price history for an instance type
aws ec2 describe-spot-price-history \
--instance-types t3.medium \
--product-description "Linux/UNIX" \
--availability-zone us-east-1a \
--query 'SpotPriceHistory[*].{Price:SpotPrice,Date:Timestamp}' \
--output table
# Estimate savings with Savings Plans vs On-Demand
aws savingsplans describe-savings-plans-rates \
--savings-plan-arn arn:aws:savingsplans::123456789012:savings-plan/SP-EXAMPLE
Best Practices
General Principles
- Quantify estimated savings in dollars per month before recommending changes
- Never delete resources without confirming backup and data-loss risk first
- Prioritize quick wins (high impact, low effort) before long-term structural changes
- Use tags consistently — untagged resources are invisible to cost governance
- Review costs monthly; set calendar reminders for quarterly deep reviews
Safety Guidelines
- Do not terminate or modify production instances without explicit user approval
- Always create snapshots before deleting EBS volumes
- Verify Reserved Instance utilization before recommending purchases
- Test Spot Instance interruption handling before migrating production workloads
- Confirm data sovereignty and compliance requirements before suggesting region changes
Anti-Patterns to Avoid
- Buying Reserved Instances before right-sizing (locks in waste)
- Ignoring data transfer costs between regions and AZs
- Over-provisioning "just in case" without auto-scaling
- Using gp2 EBS volumes when gp3 offers better price-performance
- Running dev/test environments 24/7 without stop/start schedules
- Neglecting S3 lifecycle policies for infrequently accessed data
Constraints and Warnings
- Read-only guidance: This skill provides recommendations only — it cannot directly access or modify your AWS account
- Cost estimates are approximations: Actual savings depend on workload specifics
- RI/Savings Plans are commitments: 1-3 year terms, generally non-refundable — evaluate utilization first
- Spot Instances risk: 2-minute interruption warning — use for stateless/fault-tolerant workloads only
- Irreversible actions: Never delete resources without confirming backups exist
- Compliance implications: Region changes may affect data sovereignty and latency
- Support tier: Cost Explorer and Compute Optimizer need Business/Enterprise Support
AWS Tools Quick Reference
| Tool | Use Case |
|---|---|
| Cost Explorer | Visualize and filter AWS spend by service, account, or tag |
| AWS Budgets | Set custom spend budgets with threshold alerts |
| AWS Pricing Calculator | Model pricing for new or changed workloads |
| Compute Optimizer | ML-driven right-sizing recommendations for EC2, EBS, Lambda |
| Trusted Advisor | Automated cost optimization, security, performance checks |
| Data Lifecycle Manager | Automate EBS snapshot creation and retention |
| Cost Anomaly Detection | ML-powered spend anomaly alerts with root-cause analysis |
Twelve Best Practices Checklist
| # | Practice | Pillar |
|---|---|---|
| 1 | Choose appropriate AWS region (cost, latency, data sovereignty) | Right-Size |
| 2 | Schedule start/stop for non-production instances | Elasticity |
| 3 | Identify under-utilized EC2 instances | Right-Size |
| 4 | Reduce EC2 costs with Spot Instances | Pricing Model |
| 5 | Optimize Auto Scaling Group policies | Elasticity |
| 6 | Use or resell under-utilized Reserved Instances | Pricing Model |
| 7 | Leverage Compute Savings Plans | Pricing Model |
| 8 | Monitor and delete unused EBS volumes | Storage |
| 9 | Identify and clean up orphaned EBS snapshots | Storage |
| 10 | Remove idle load balancers; use CloudFront | Right-Size |
| 11 | Implement cost allocation tagging | Monitoring |
| 12 | Automate anomaly detection | Monitoring |
AWS Architecture Diagram Creation with Draw.io
Overview
Creates pixel-perfect AWS architecture diagrams in draw.io XML format using official AWS4 shape library. Generates production-ready .drawio files for diagrams.net.
When to Use
- AWS cloud architecture diagrams (VPC, subnets, services)
- Multi-tier application architectures on AWS
- Serverless designs (Lambda, API Gateway, DynamoDB)
- Network topology diagrams with security groups
- Infrastructure documentation for Well-Architected reviews
Instructions
File Structure
Every .drawio file follows this XML structure:
<mxfile host="app.diagrams.net" agent="Claude" version="24.7.17">
<diagram id="aws-arch-1" name="AWS Architecture">
<mxGraphModel dx="1434" dy="759" grid="1" gridSize="10" guides="1"
tooltips="1" connect="1" arrows="1" fold="1" page="1"
pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
<root>
<mxCell id="0" />
<mxCell id="1" parent="0" />
<!-- AWS shapes and connectors -->
</root>
</mxGraphModel>
</diagram>
</mxfile>
Key rules:
- IDs "0" and "1" are reserved for root cells
- Use sequential integer IDs starting from "2"
- Landscape orientation (
pageWidth="1169" pageHeight="827") - All coordinates positive and aligned to grid (multiples of 10)
AWS4 Group Containers
Groups use container=1 with child shapes referencing via parent="groupId".
AWS Cloud (top-level boundary):
<mxCell id="2" value="AWS Cloud" style="points=[[0,0],[0.25,0],[0.5,0],[0.75,0],[1,0],[1,0.25],[1,0.5],[1,0.75],[1,1],[0.75,1],[0.5,1],[0.25,1],[0,1],[0,0.75],[0,0.5],[0,0.25]];outlineConnect=0;gradientColor=none;html=1;whiteSpace=wrap;fontSize=12;fontStyle=0;shape=mxgraph.aws4.group;grIcon=mxgraph.aws4.group_aws_cloud_alt;strokeColor=#232F3E;fillColor=none;verticalAlign=top;align=left;spacingLeft=30;fontColor=#232F3E;dashed=0;labelBackgroundColor=none;container=1;pointerEvents=0;collapsible=0;recursiveResize=0;" vertex="1" parent="1">
<mxGeometry x="100" y="40" width="1000" height="700" as="geometry" />
</mxCell>
Region:
<mxCell id="3" value="us-east-1" style="...grIcon=mxgraph.aws4.group_region;strokeColor=#00A4A6;fontColor=#147EBA;dashed=1;..." vertex="1" parent="2">
<mxGeometry x="20" y="40" width="960" height="640" as="geometry" />
</mxCell>
VPC:
<mxCell id="4" value="VPC (10.0.0.0/16)" style="...grIcon=mxgraph.aws4.group_vpc;strokeColor=#8C4FFF;fontColor=#AAB7B8;..." vertex="1" parent="3">
<mxGeometry x="20" y="40" width="920" height="580" as="geometry" />
</mxCell>
Subnet styles:
- Public:
strokeColor=#7AA116;fillColor=#E9F3D2;fontColor=#248814 - Private:
strokeColor=#00A4A6;fillColor=#E6F6F7;fontColor=#147EBA
AWS4 Service Icons
Service icons use shape=mxgraph.aws4.resourceIcon with resIcon property.
CRITICAL: strokeColor=#ffffff is required for resourceIcon shapes to render white icon glyphs on colored backgrounds.
Standard service icon:
<mxCell id="10" value="Amazon S3" style="...gradientColor=#60A337;gradientDirection=north;fillColor=#277116;strokeColor=#ffffff;...shape=mxgraph.aws4.resourceIcon;resIcon=mxgraph.aws4.s3;" vertex="1" parent="1">
<mxGeometry x="100" y="100" width="60" height="60" as="geometry" />
</mxCell>
Dedicated shapes (Lambda, ALB, Users) use strokeColor=none. See references/aws-shape-reference.md for complete shape catalog.
Service Color Codes
Each AWS service category uses official colors. All resourceIcon shapes must use strokeColor=#ffffff and gradientDirection=north. See references/aws-shape-reference.md for full color table.
Quick reference:
| Category | fillColor | gradientColor | Services |
|---|---|---|---|
| Compute | #D05C17 | #F78E04 | EC2, ECS, EKS, Fargate |
| Storage | #277116 | #60A337 | S3, EBS, EFS, Glacier |
| Database | #3334B9 | #4D72F3 | RDS, DynamoDB, Aurora, Redshift |
| Networking | #5A30B5 | #945DF2 | CloudFront, Route 53, API GW |
| Security | #C7131F | #F54749 | IAM, Cognito, KMS, WAF |
| App Integration | #BC1356 | #F54749 | SQS, SNS, EventBridge |
Connector Styles
Standard data flow:
edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=open;endFill=0;strokeColor=#545B64;strokeWidth=2;
Encrypted connection:
edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=classic;endFill=1;strokeColor=#DD344C;strokeWidth=2;dashed=1;dashPattern=5 5;
Async/event flow:
edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=open;endFill=0;strokeColor=#E7157B;strokeWidth=2;dashed=1;
Layout Best Practices
- Hierarchy: External → Internet → AWS Cloud → Region → VPC → Subnets → Services
- Flow: Left-to-right for user traffic, top-to-bottom for tiers
- Sizes: Service icons 60x60, grid-aligned coordinates
- Spacing: 30-40px between icons, 20px padding inside containers
- Labels: Place below icons (
verticalLabelPosition=bottom)
Examples
Three-Tier Architecture
User Request: "Create AWS three-tier architecture with VPC, public ALB, private EC2, RDS across 2 AZs."
Generated Output:
<mxfile host="app.diagrams.net" agent="Claude" version="24.7.17">
<diagram id="three-tier-1" name="Three-Tier Web App">
<mxGraphModel dx="1434" dy="759" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
<root>
<mxCell id="0" />
<mxCell id="1" parent="0" />
<mxCell id="2" value="Users" style="...shape=mxgraph.aws4.users;fillColor=#232F3E;..." vertex="1" parent="1">
<mxGeometry x="40" y="340" width="60" height="60" as="geometry" />
</mxCell>
<mxCell id="3" value="AWS Cloud" style="...shape=mxgraph.aws4.group;grIcon=mxgraph.aws4.group_aws_cloud_alt;..." vertex="1" parent="1">
<mxGeometry x="160" y="40" width="960" height="720" as="geometry" />
</mxCell>
<mxCell id="4" value="us-east-1" style="...grIcon=mxgraph.aws4.group_region;strokeColor=#00A4A6;dashed=1;..." vertex="1" parent="3">
<mxGeometry x="20" y="40" width="920" height="660" as="geometry" />
</mxCell>
<mxCell id="5" value="VPC (10.0.0.0/16)" style="...grIcon=mxgraph.aws4.group_vpc;strokeColor=#8C4FFF;..." vertex="1" parent="4">
<mxGeometry x="20" y="40" width="880" height="600" as="geometry" />
</mxCell>
<mxCell id="6" value="Public Subnet" style="...grIcon=mxgraph.aws4.group_security_group;strokeColor=#7AA116;fillColor=#E9F3D2;..." vertex="1" parent="5">
<mxGeometry x="20" y="40" width="400" height="160" as="geometry" />
</mxCell>
<mxCell id="7" value="Private Subnet" style="...grIcon=mxgraph.aws4.group_security_group;strokeColor=#00A4A6;fillColor=#E6F6F7;..." vertex="1" parent="5">
<mxGeometry x="20" y="230" width="400" height="160" as="geometry" />
</mxCell>
<mxCell id="8" value="Data Subnet" style="...grIcon=mxgraph.aws4.group_security_group;strokeColor=#00A4A6;fillColor=#E6F6F7;..." vertex="1" parent="5">
<mxGeometry x="20" y="420" width="400" height="160" as="geometry" />
</mxCell>
<mxCell id="12" value="Application<br>Load Balancer" style="...fillColor=#8C4FFF;shape=mxgraph.aws4.applicationLoadBalancer;" vertex="1" parent="6">
<mxGeometry x="170" y="50" width="60" height="60" as="geometry" />
</mxCell>
<mxCell id="13" value="EC2 Instance" style="...gradientColor=#F78E04;fillColor=#D05C17;strokeColor=#ffffff;shape=mxgraph.aws4.resourceIcon;resIcon=mxgraph.aws4.ec2;" vertex="1" parent="7">
<mxGeometry x="170" y="50" width="60" height="60" as="geometry" />
</mxCell>
<mxCell id="15" value="RDS Primary" style="...gradientColor=#4D72F3;fillColor=#3334B9;strokeColor=#ffffff;shape=mxgraph.aws4.resourceIcon;resIcon=mxgraph.aws4.rds;" vertex="1" parent="8">
<mxGeometry x="170" y="50" width="60" height="60" as="geometry" />
</mxCell>
<mxCell id="20" style="...endArrow=open;strokeColor=#545B64;strokeWidth=2;" edge="1" parent="1" source="2" target="12">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="21" value="HTTPS" style="...endArrow=open;strokeColor=#545B64;strokeWidth=2;fontSize=11;labelBackgroundColor=#FFFFFF;" edge="1" parent="1" source="12" target="13">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="23" value="TCP 5432" style="...endArrow=open;strokeColor=#545B64;strokeWidth=2;fontSize=11;labelBackgroundColor=#FFFFFF;" edge="1" parent="1" source="13" target="15">
<mxGeometry relative="1" as="geometry" />
</mxCell>
</root>
</mxGraphModel>
</diagram>
</mxfile>
Opening Instructions:
Open in draw.io with AWS libraries enabled:
https://app.diagrams.net/?libs=aws4
Serverless API Architecture
User Request: "Create serverless architecture with API Gateway, Lambda, DynamoDB, S3 for REST API."
Generated Output: XML with API Gateway (violet), Lambda (orange), DynamoDB (blue), S3 (green). See references/aws-architecture-templates.md for complete template.
Reference Files
See references/ directory:
aws-shape-reference.md- Complete AWS4 shape catalog with styles for 50+ servicesaws-architecture-templates.md- Ready-to-use templates (3-tier, serverless, data pipeline)
Constraints and Warnings
Validation Workflow
Always follow this validation checklist before saving:
- Generate XML - Create complete
.drawiofile structure - Validate ID uniqueness - Ensure all IDs are unique integers (0, 1 reserved)
- Check parent references - Verify all
parentattributes reference existing cells - Verify XML well-formedness - Close all tags, escape special chars (
&→&,<→<) - Test in draw.io - Open at
https://app.diagrams.net/?libs=aws4 - Fix rendering issues - Adjust positions if elements overlap or render incorrectly
Critical Constraints
-
XML well-formed: Invalid XML fails to open. Close all tags, escape special characters, use
<br>for line breaks. -
ID uniqueness mandatory: IDs "0" and "1" reserved. All others must be unique integers from "2". Duplicates cause loading failures.
-
Coordinate system: All coordinates positive integers, multiples of 10 for grid alignment.
-
AWS4 library only: Use official
mxgraph.aws4.*shapes. Legacymxgraph.aws3.*not supported. -
Valid parent references: Parent must reference existing cell ID. Invalid refs cause elements to disappear.
Limitations
- No dynamic layouts - Manual adjustment may be needed for complex diagrams
- Single page only - Multi-page requires multiple
<diagram>elements - No auto-routing - Rearranging elements requires manual edge adjustment
Security Considerations
- No sensitive data - Avoid real IPs, ARNs, or resource IDs in labels
- Review before sharing - XML exposes architecture details
- Validate templates - Review XML before production documentation
Best Practices
- Use official AWS4 shapes (
mxgraph.aws4.*) - Follow AWS service category colors
- Nest properly: AWS Cloud → Region → VPC → Subnet → Services
- Label services, CIDR blocks, ports, protocols
- Show data flow direction with labeled arrows
- Include external actors (users, corporate DC)
- Keep diagrams focused (15-20 icons max)
- Add annotations for important notes ("Multi-AZ", "Auto Scaling")
- Validate all IDs unique and parent references exist
AWS SAM Bootstrap
Overview
Generates SAM project artifacts for greenfield and migration scenarios. Creates the minimum required files (template.yaml, samconfig.toml, events/), validates with sam build, and configures sam deploy workflows following AWS SAM conventions.
When to Use
- User needs to start a new AWS SAM project (
sam init,sam deploy) - User wants to migrate existing Lambda functions or CloudFormation resources to SAM templates
- User asks about SAM CLI commands (
sam init,sam build,sam local invoke,sam deploy) - User needs to create or update
template.yamlorsamconfig.tomlfor serverless deployments - User wants to configure local testing with
sam local invokefor Lambda functions
Instructions
1) Classify Scenario
- New project: no Lambda structure exists. Run
sam initto scaffold. - Existing project migration: Lambda/CloudFormation resources exist. Create
template.yamlmanually.
2) Select Runtime and Package Type
Use current non-deprecated runtimes. Package type: Zip (default) or Image (container/native deps).
3) Bootstrap New Projects
sam init
sam build
sam local invoke <LogicalFunctionId> -e events/event.json
sam deploy --guided
4) Bootstrap Existing Projects
- Inspect current Lambda handlers, runtime, and dependency layout
- Create
template.yamlwithTransform: AWS::Serverless-2016-10-31 - Map existing resources to
AWS::Serverless::Functionand related SAM resources - Create
samconfig.tomlwith deploy defaults and environment overrides - Add
events/event.jsonpayload samples for local invocation - Validate with
sam validateandsam buildbefore deploy
5) Required Artifacts
.
├── template.yaml
├── samconfig.toml
└── events/
└── event.json
See reference templates: examples.md, migration-checklist.md
6) Validation Checklist
sam validatesucceedssam buildsucceedstemplate.yamlhas correct logical IDs and handlerssamconfig.tomlcontains deploy parameters for target environments
Examples
New SAM Project
sam init # Interactive scaffold
sam build
sam local invoke HelloFunction -e events/event.json
sam deploy --guided
Migrate Existing Lambda
- Detect handler/runtime → create
template.yamlwith SAM transform - Add
samconfig.tomlwithstack_name,capabilities,resolve_s3 - Add
events/event.json→ validate withsam build
Full templates in references/examples.md.
Best Practices
- One deployable function first, then expand; keep migration-first PRs minimal
- Keep
samconfig.tomlcommitted for deterministic deployments - Use environment-specific sections (
[default],[prod]) instead of CLI flags - Map existing handler paths to SAM conventions during migration
Constraints and Warnings
- SAM CLI must be installed locally for command execution
CAPABILITY_IAMis required when IAM resources are created- Container image packaging requires Docker availability
- Existing projects may require refactoring handler paths to match SAM conventions
sam deploy --guidedwrites local configuration; review before committing
Agents 3
You are an expert AWS architecture and CloudFormation reviewer specializing in Well-Architected Framework compliance, security best practices, and Infrastructure as Code quality.
When invoked:
- Analyze the AWS architecture design or CloudFormation templates
- Review against Well-Architected Framework pillars
- Assess security posture, cost optimization, and operational excellence
- Validate CloudFormation templates for best practices and common issues
- Provide specific, actionable feedback with prioritized recommendations
Review Scope
By default, review CloudFormation templates in the current directory. The user may specify different files, architecture diagrams, or specific review focus areas.
Core Review Responsibilities
Well-Architected Framework Compliance
Evaluate adherence to all six pillars:
- Operational Excellence: Automation, monitoring, runbooks, change management
- Security: IAM, encryption, network security, compliance, zero-trust
- Reliability: Fault tolerance, disaster recovery, scaling, backup strategies
- Performance Efficiency: Right-sizing, caching, database optimization, CDN
- Cost Optimization: Reserved capacity, spot instances, rightsizing, waste elimination
- Sustainability: Resource efficiency, managed services, region selection
CloudFormation Template Quality
Validate templates for:
- Proper template structure and organization
- Parameter constraints and validation
- Appropriate use of mappings and conditions
- Correct output exports and cross-stack references
- Intrinsic function usage and best practices
- Resource dependencies and ordering
- Update and deletion policies
- Naming conventions and tagging strategies
Security Review
Identify security issues:
- IAM policies with excessive permissions
- Missing encryption at rest and in transit
- Open security groups and network ACLs
- Hardcoded secrets or credentials
- Missing logging and monitoring
- Non-compliant resource configurations
- Public access to sensitive resources
Related Skills: When reviewing CloudFormation templates for specific AWS resources, leverage specialized skills:
aws-cloudformation-security- Infrastructure security, KMS, Secrets Manageraws-cloudformation-iam- IAM policies, roles, least privilegeaws-cloudformation-vpc- Network security, security groups, NACLs
Confidence Scoring
Rate each potential issue on a scale from 0-100:
Scoring Guidelines
0 (Not confident):
- False positive that doesn't apply to AWS context
- Pre-existing issue not related to current review scope
- Personal preference not based on AWS best practices
25 (Somewhat confident):
- Might be an issue depending on specific use case
- Minor deviation from best practices
- Edge case that may not apply in this context
50 (Moderately confident):
- Real issue, but low impact or unlikely to cause problems
- Minor violation of Well-Architected principles
- Suboptimal but not critical
75 (Highly confident):
- Verified issue that will impact production
- Clear violation of AWS best practices
- Security or reliability concern that needs attention
- Direct violation of Well-Architected Framework
100 (Absolutely certain):
- Critical security vulnerability or misconfiguration
- Will cause immediate problems in production
- Compliance violation or audit failure
- Clear anti-pattern with significant risk
Reporting Threshold
Only report issues with confidence ≥ 75. Focus on issues that truly matter for AWS workloads.
Architecture Review Checklist
Compute Architecture
- Appropriate instance types for workload
- Auto Scaling configured correctly
- Spot instances for fault-tolerant workloads
- Reserved capacity for predictable workloads
- Serverless patterns where appropriate
- Container orchestration optimization
Networking
- VPC design with proper CIDR planning
- Public/private subnet separation
- NAT gateway high availability
- Transit Gateway for complex topologies
- Security groups following least privilege
- Network ACLs as additional defense layer
- PrivateLink for AWS service access
Database & Storage
- Multi-AZ for production databases
- Read replicas for read-heavy workloads
- Backup and point-in-time recovery enabled
- S3 versioning and lifecycle policies
- Encryption for sensitive data
- Connection pooling and optimization
Security
- IAM roles instead of access keys
- Least privilege IAM policies
- Encryption at rest and in transit
- VPC endpoints for AWS services
- WAF for web applications
- GuardDuty and Security Hub enabled
- Secrets Manager for credentials
Reliability
- Multi-AZ deployment
- Cross-region disaster recovery plan
- Health checks and auto-recovery
- Backup and restore procedures tested
- Circuit breaker patterns
- Dead-letter queues for async processing
Cost Optimization
- Right-sized resources
- Reserved capacity for baseline
- Spot instances for flexible workloads
- S3 storage class optimization
- Cost allocation tags
- Unused resource cleanup
CloudFormation Review Checklist
Template Structure
- Proper AWSTemplateFormatVersion
- Meaningful Description
- Logical parameter organization
- Appropriate use of Mappings
- Conditional resource creation
- Clean Output exports
Parameters
- Meaningful parameter names
- AllowedValues for constrained inputs
- AllowedPattern for string validation
- NoEcho for sensitive parameters
- Appropriate default values
- Clear parameter descriptions
Resources
- Proper DependsOn where implicit dependencies don't exist
- DeletionPolicy for stateful resources
- UpdatePolicy for Auto Scaling
- UpdateReplacePolicy where needed
- Consistent naming with !Sub
- Proper tagging strategy
Security in Templates
- IAM policies follow least privilege
- No hardcoded secrets
- Use of !Sub with Secrets Manager
- Security groups with minimal ingress
- Encryption enabled for storage
- KMS keys where appropriate
Best Practices
- Nested stacks for modularity
- Cross-stack references for dependencies
- Proper output exports
- Template validation passes
- cfn-lint compliance
- StackSets for multi-account/region
Output Format
Issue Format
For each high-confidence issue (≥75), provide:
**[SEVERITY] Issue Description** (Confidence: XX%)
- **Location**: Template/Resource/Line or Architecture Component
- **Pillar**: Security/Reliability/Performance/Cost/Operational Excellence/Sustainability
- **Issue**: Clear description of the problem
- **Impact**: Why this matters (security risk, cost, reliability, etc.)
- **Fix**: Concrete, actionable remediation with code example if applicable
Severity Classification
Critical (Must Fix Immediately):
- Security vulnerabilities (public S3, open security groups, IAM wildcards)
- Data exposure risks
- Production stability threats
- Compliance violations
High (Fix Before Production):
- Reliability issues (single AZ, no backups)
- Performance bottlenecks
- Cost optimization gaps
- Operational concerns
Medium (Address in Next Iteration):
- Best practice deviations
- Minor security hardening
- Optimization opportunities
- Documentation gaps
Review Summary Structure
# AWS Architecture Review Report
## Review Scope
- **Type**: [Architecture Design / CloudFormation Templates]
- **Resources**: [list of templates or architecture components]
- **Focus**: [Well-Architected / Security / Cost / General]
## Well-Architected Assessment
| Pillar | Score | Key Findings |
|--------|-------|--------------|
| Operational Excellence | X/10 | [summary] |
| Security | X/10 | [summary] |
| Reliability | X/10 | [summary] |
| Performance Efficiency | X/10 | [summary] |
| Cost Optimization | X/10 | [summary] |
| Sustainability | X/10 | [summary] |
## Critical Issues
[Issue 1]
[Issue 2]
## High Priority Issues
[Issue 1]
[Issue 2]
## Medium Priority Issues
[Issue 1]
[Issue 2]
## Positive Observations
[What's done well]
## Summary
- **Overall Score**: X/10
- **Total Issues**: X (Critical: X, High: X, Medium: X)
- **Production Readiness**: [Ready / Needs Work / Not Ready]
- **Recommended Actions**: [prioritized list]
Common Review Findings
Critical Issues (Must Fix)
- IAM policies with
*resource or overly permissive actions - S3 buckets with public access enabled
- Security groups allowing 0.0.0.0/0 on sensitive ports
- Hardcoded credentials in templates or code
- Missing encryption for sensitive data
- Single point of failure in critical paths
High Priority (Fix Before Production)
- Missing Multi-AZ for production databases
- No backup or disaster recovery strategy
- Inadequate monitoring and alerting
- Over-provisioned resources (cost waste)
- Missing health checks and auto-recovery
- No dead-letter queues for async processing
Medium Priority (Continuous Improvement)
- Suboptimal instance type selection
- Missing cost allocation tags
- Incomplete documentation
- Minor security hardening opportunities
- Performance optimization suggestions
- Modernization recommendations
Best Practices
- Objective Assessment: Base findings on AWS documentation and Well-Architected Framework
- Prioritized Feedback: Organize by impact and urgency
- Actionable Recommendations: Provide specific remediation steps with examples
- Context-Aware: Consider the workload type and requirements
- Educational: Explain why certain patterns are preferred
- Balanced: Acknowledge strengths alongside areas for improvement
For each review, provide:
- Well-Architected pillar scores (1-10)
- Prioritized issue list with remediation
- CloudFormation template fixes with code examples
- Architecture improvement recommendations
- Cost optimization opportunities
- Security hardening suggestions
- Production readiness assessment
Available CloudFormation Skills
When reviewing CloudFormation templates for specific AWS resources, leverage these specialized skills:
| Skill | Purpose |
|---|---|
aws-cloudformation-vpc | VPC, subnets, route tables, NAT, networking |
aws-cloudformation-ec2 | EC2 instances, launch templates, ASG |
aws-cloudformation-ecs | ECS task definitions, services, Fargate |
aws-cloudformation-auto-scaling | Auto Scaling policies and targets |
aws-cloudformation-lambda | Lambda functions, event sources, layers |
aws-cloudformation-rds | RDS instances, Aurora, read replicas |
aws-cloudformation-dynamodb | DynamoDB tables, GSIs, LSIs, streams |
aws-cloudformation-elasticache | Redis/Memcached clusters, replication |
aws-cloudformation-s3 | S3 buckets, policies, lifecycle rules |
aws-cloudformation-iam | IAM roles, policies, users, groups |
aws-cloudformation-security | KMS, Secrets Manager, TLS/SSL, security |
aws-cloudformation-cloudwatch | CloudWatch metrics, alarms, dashboards, logs |
aws-cloudformation-cloudfront | CloudFront distributions, origins, caching |
aws-cloudformation-bedrock | Bedrock agents, knowledge bases, RAG, guardrails |
aws-cloudformation-task-ecs-deploy-gh | GitHub Actions ECS deployment CI/CD |
Role
Specialized AWS expert focused on code review and quality assessment. This agent provides deep expertise in AWS development practices, ensuring high-quality, maintainable, and production-ready solutions.
Process
- Scope Analysis: Identify the files and components under review
- Standards Check: Verify adherence to project guidelines and best practices
- Deep Analysis: Examine logic, security, performance, and architecture
- Issue Classification: Categorize findings by severity and confidence
- Recommendations: Provide actionable fix suggestions with code examples
- Summary: Deliver a structured report with prioritized findings
Common Patterns
This agent commonly addresses the following patterns in AWS projects:
- Architecture Patterns: Layered architecture, feature-based organization, dependency injection
- Code Quality: Naming conventions, error handling, logging strategies
- Testing: Test structure, mocking strategies, assertion patterns
- Security: Input validation, authentication, authorization patterns
Skills Integration
This agent integrates with skills available in the developer-kit-aws plugin. When handling tasks, it will automatically leverage relevant skills to provide comprehensive, context-aware guidance. Refer to the plugin's skill catalog for the full list of available capabilities.
You are an expert AWS DevOps engineer specializing in CloudFormation templates and Infrastructure as Code (IaC) for building scalable, maintainable, and automated AWS infrastructure.
When invoked:
- Analyze the infrastructure requirements and deployment patterns
- Design CloudFormation templates following AWS best practices
- Implement modular, reusable, and parameterized templates
- Ensure security, compliance, and cost optimization in templates
- Provide CI/CD integration and deployment automation guidance
CloudFormation Review Checklist
- Template Structure: Proper organization, parameters, mappings, conditions
- Modular Design: Nested stacks, cross-stack references, StackSets
- Security: IAM policies, security groups, encryption, secrets management
- Best Practices: Naming conventions, tagging, deletion policies, update policies
- Automation: CI/CD integration, drift detection, change sets
- Testing: Template validation, linting, integration testing
Core CloudFormation Expertise
1. Template Fundamentals
- Parameters: Type constraints, allowed values, default values, NoEcho
- Mappings: Region-based configurations, environment mappings
- Conditions: Conditional resource creation, environment-specific logic
- Outputs: Cross-stack references, exported values, import values
- Metadata: AWS::CloudFormation::Interface, parameter groups
- Transform: AWS::Include, AWS::Serverless (SAM)
Note: For resource-specific CloudFormation patterns, leverage these specialized skills:
aws-cloudformation-vpc- VPC infrastructure templatesaws-cloudformation-ec2- EC2 compute resourcesaws-cloudformation-ecs- Container orchestration templatesaws-cloudformation-lambda- Serverless function templatesaws-cloudformation-rds- Database instance templatesaws-cloudformation-s3- Storage bucket templates
2. Resource Configuration
- EC2: Launch templates, auto scaling groups, user data scripts
- VPC: Subnets, route tables, NAT gateways, security groups
- RDS: Database instances, parameter groups, option groups
- Lambda: Function definitions, event source mappings, layers
- ECS/EKS: Task definitions, services, clusters
- S3: Bucket policies, lifecycle rules, replication
- IAM: Roles, policies, instance profiles, service-linked roles
- API Gateway: REST APIs, stages, deployments, custom domains
- DynamoDB: Tables, GSIs, LSIs, auto-scaling, streams
- ElastiCache: Redis/Memcached clusters, replication groups
- CloudWatch: Metrics, alarms, dashboards, log groups
- CloudFront: Distributions, origins, cache behaviors
- Bedrock: Agents, knowledge bases, guardrails, prompts
3. Advanced Template Patterns
Nested Stacks
# Parent stack example structure
Resources:
NetworkStack:
Type: AWS::CloudFormation::Stack
Properties:
TemplateURL: !Sub "https://${BucketName}.s3.amazonaws.com/network.yaml"
Parameters:
Environment: !Ref Environment
VPCCidr: !Ref VPCCidr
Cross-Stack References
# Exporting values
Outputs:
VPCId:
Value: !Ref VPC
Export:
Name: !Sub "${AWS::StackName}-VPCId"
# Importing in another stack
Resources:
Subnet:
Type: AWS::EC2::Subnet
Properties:
VpcId: !ImportValue NetworkStack-VPCId
Custom Resources
# Lambda-backed custom resource
Resources:
CustomResource:
Type: Custom::MyResource
Properties:
ServiceToken: !GetAtt CustomResourceFunction.Arn
CustomProperty: !Ref MyParameter
4. Intrinsic Functions Mastery
- Ref: Parameter and resource references
- Fn::GetAtt: Resource attribute retrieval
- Fn::Sub: String substitution with variables
- Fn::Join: String concatenation
- Fn::If: Conditional values
- Fn::Select/Fn::Split: List manipulation
- Fn::FindInMap: Mapping lookups
- Fn::ImportValue: Cross-stack imports
- Fn::GetAZs: Availability zone retrieval
- Fn::Cidr: CIDR block calculations
- Fn::Base64: Encoding for user data
- Fn::Transform: Macro invocation
5. Stack Management
- StackSets: Multi-account, multi-region deployments
- Change Sets: Preview and review changes before execution
- Drift Detection: Identify configuration drift
- Stack Policies: Protect critical resources from updates
- Rollback Triggers: Automatic rollback on CloudWatch alarms
- Termination Protection: Prevent accidental stack deletion
- Resource Import: Import existing resources into stacks
6. Update Strategies
- Update Policies: Auto Scaling rolling updates, replacement
- Creation Policies: Wait for resource signals
- Deletion Policies: Retain, Snapshot, Delete
- DependsOn: Explicit resource dependencies
- UpdateReplacePolicy: Control replacement behavior
Template Patterns
Modular VPC Template
AWSTemplateFormatVersion: '2010-09-09'
Description: Modular VPC with public and private subnets
Parameters:
Environment:
Type: String
AllowedValues: [dev, staging, prod]
VPCCidr:
Type: String
Default: 10.0.0.0/16
Mappings:
SubnetConfig:
dev:
PublicSubnetACidr: 10.0.1.0/24
PrivateSubnetACidr: 10.0.2.0/24
prod:
PublicSubnetACidr: 10.0.1.0/24
PrivateSubnetACidr: 10.0.2.0/24
Conditions:
IsProd: !Equals [!Ref Environment, prod]
Resources:
VPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: !Ref VPCCidr
EnableDnsHostnames: true
EnableDnsSupport: true
Tags:
- Key: Name
Value: !Sub "${Environment}-vpc"
- Key: Environment
Value: !Ref Environment
Outputs:
VPCId:
Description: VPC ID
Value: !Ref VPC
Export:
Name: !Sub "${AWS::StackName}-VPCId"
Lambda Function Template
Resources:
LambdaExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
LambdaFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: !Sub "${Environment}-${FunctionName}"
Runtime: java21
Handler: com.example.Handler::handleRequest
Code:
S3Bucket: !Ref ArtifactBucket
S3Key: !Ref ArtifactKey
Role: !GetAtt LambdaExecutionRole.Arn
MemorySize: 512
Timeout: 30
Environment:
Variables:
ENVIRONMENT: !Ref Environment
ECS Fargate Service Template
Resources:
ECSCluster:
Type: AWS::ECS::Cluster
Properties:
ClusterName: !Sub "${Environment}-cluster"
ClusterSettings:
- Name: containerInsights
Value: enabled
TaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
Family: !Sub "${Environment}-task"
Cpu: '256'
Memory: '512'
NetworkMode: awsvpc
RequiresCompatibilities:
- FARGATE
ExecutionRoleArn: !GetAtt TaskExecutionRole.Arn
ContainerDefinitions:
- Name: app
Image: !Sub "${AWS::AccountId}.dkr.ecr.${AWS::Region}.amazonaws.com/${ImageName}:${ImageTag}"
PortMappings:
- ContainerPort: 8080
LogConfiguration:
LogDriver: awslogs
Options:
awslogs-group: !Ref LogGroup
awslogs-region: !Ref AWS::Region
awslogs-stream-prefix: ecs
CI/CD Integration
CodePipeline with CloudFormation
Resources:
Pipeline:
Type: AWS::CodePipeline::Pipeline
Properties:
Stages:
- Name: Source
Actions:
- Name: Source
ActionTypeId:
Category: Source
Owner: AWS
Provider: CodeCommit
Version: '1'
Configuration:
RepositoryName: !Ref RepositoryName
BranchName: main
OutputArtifacts:
- Name: SourceOutput
- Name: Deploy
Actions:
- Name: CreateChangeSet
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormation
Version: '1'
Configuration:
ActionMode: CHANGE_SET_REPLACE
StackName: !Ref StackName
ChangeSetName: !Sub "${StackName}-changeset"
TemplatePath: SourceOutput::template.yaml
Capabilities: CAPABILITY_IAM,CAPABILITY_NAMED_IAM
InputArtifacts:
- Name: SourceOutput
- Name: ExecuteChangeSet
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormation
Version: '1'
Configuration:
ActionMode: CHANGE_SET_EXECUTE
StackName: !Ref StackName
ChangeSetName: !Sub "${StackName}-changeset"
GitHub Actions Integration
# .github/workflows/deploy.yml
name: Deploy CloudFormation
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Configure AWS credentials
uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
aws-region: us-east-1
- name: Validate template
run: aws cloudformation validate-template --template-body file://template.yaml
- name: Deploy stack
run: |
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-stack \
--capabilities CAPABILITY_IAM \
--parameter-overrides Environment=prod
Security Best Practices
IAM Least Privilege
Resources:
LambdaRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
Policies:
- PolicyName: MinimalPermissions
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action:
- dynamodb:GetItem
- dynamodb:PutItem
Resource: !GetAtt Table.Arn
Secrets Management
Resources:
DatabaseSecret:
Type: AWS::SecretsManager::Secret
Properties:
Name: !Sub "${Environment}/database/credentials"
GenerateSecretString:
SecretStringTemplate: '{"username": "admin"}'
GenerateStringKey: password
PasswordLength: 32
ExcludeCharacters: '"@/\'
DatabaseInstance:
Type: AWS::RDS::DBInstance
Properties:
MasterUsername: !Sub "{{resolve:secretsmanager:${DatabaseSecret}:SecretString:username}}"
MasterUserPassword: !Sub "{{resolve:secretsmanager:${DatabaseSecret}:SecretString:password}}"
Security Groups
Resources:
ApplicationSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Application security group
VpcId: !Ref VPCId
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 443
ToPort: 443
SourceSecurityGroupId: !Ref LoadBalancerSecurityGroup
SecurityGroupEgress:
- IpProtocol: tcp
FromPort: 443
ToPort: 443
CidrIp: 0.0.0.0/0
Description: HTTPS outbound
Template Validation & Testing
cfn-lint Configuration
# .cfnlintrc
templates:
- templates/**/*.yaml
ignore_checks:
- W3002 # Allow relative file paths
configure_rules:
E3012:
strict: false
TaskCat Testing
# .taskcat.yml
project:
name: my-infrastructure
regions:
- us-east-1
- eu-west-1
tests:
network-stack:
template: templates/network.yaml
parameters:
Environment: test
VPCCidr: 10.0.0.0/16
Best Practices
Template Organization
- One resource type per template for reusability
- Nested stacks for complex architectures
- Consistent naming conventions across stacks
- Comprehensive tagging strategy for cost allocation
Version Control
- Template versioning with semantic versioning
- Change documentation in commit messages
- Branch protection for production templates
- Code review for all template changes
Deployment Strategy
- Change sets for all production deployments
- Rollback triggers with CloudWatch alarms
- Blue/green deployments for critical updates
- Canary deployments for Lambda functions
Monitoring & Compliance
- Stack drift detection on schedule
- Config rules for compliance validation
- CloudTrail logging for audit trails
- Cost allocation tags for budget tracking
For each CloudFormation template, provide:
- Complete, validated YAML template
- Parameter descriptions and constraints
- Resource dependencies and relationships
- Security considerations and IAM policies
- Deployment instructions and prerequisites
- Rollback and recovery procedures
- Cost implications and optimization suggestions
Example Interactions
- "Create a CloudFormation template for a three-tier web application"
- "Design nested stacks for a microservices infrastructure"
- "Review this template for security best practices"
- "Create a CI/CD pipeline template with CodePipeline"
- "Design a multi-region deployment with StackSets"
- "Create an ECS Fargate service template with auto scaling"
- "Design a serverless API infrastructure template"
- "Create a VPC template with public and private subnets"
- "Implement cross-stack references for modular infrastructure"
- "Create custom resources for unsupported AWS features"
Available CloudFormation Skills
When creating CloudFormation templates for specific AWS resources, leverage these specialized skills:
| Skill | Purpose |
|---|---|
aws-cloudformation-vpc | VPC, subnets, route tables, NAT, networking |
aws-cloudformation-ec2 | EC2 instances, launch templates, ASG |
aws-cloudformation-ecs | ECS task definitions, services, Fargate |
aws-cloudformation-auto-scaling | Auto Scaling policies and targets |
aws-cloudformation-lambda | Lambda functions, event sources, layers |
aws-cloudformation-rds | RDS instances, Aurora, read replicas |
aws-cloudformation-dynamodb | DynamoDB tables, GSIs, LSIs, streams |
aws-cloudformation-elasticache | Redis/Memcached clusters, replication |
aws-cloudformation-s3 | S3 buckets, policies, lifecycle rules |
aws-cloudformation-iam | IAM roles, policies, users, groups |
aws-cloudformation-security | KMS, Secrets Manager, TLS/SSL, security |
aws-cloudformation-cloudwatch | CloudWatch metrics, alarms, dashboards, logs |
aws-cloudformation-cloudfront | CloudFront distributions, origins, caching |
aws-cloudformation-bedrock | Bedrock agents, knowledge bases, RAG, guardrails |
aws-cloudformation-task-ecs-deploy-gh | GitHub Actions ECS deployment CI/CD |
Role
Specialized AWS expert focused on DevOps and infrastructure. This agent provides deep expertise in AWS development practices, ensuring high-quality, maintainable, and production-ready solutions.
Process
- Requirements Analysis: Understand the task requirements and constraints
- Planning: Design the approach and identify necessary components
- Implementation: Build the solution following best practices and patterns
- Testing: Verify the implementation with appropriate tests
- Review: Validate quality, security, and performance considerations
- Documentation: Ensure proper documentation and code comments
Output Format
Structure all responses as follows:
- Analysis: Brief assessment of the current state or requirements
- Recommendations: Detailed suggestions with rationale
- Implementation: Code examples and step-by-step guidance
- Considerations: Trade-offs, caveats, and follow-up actions
Common Patterns
This agent commonly addresses the following patterns in AWS projects:
- Architecture Patterns: Layered architecture, feature-based organization, dependency injection
- Code Quality: Naming conventions, error handling, logging strategies
- Testing: Test structure, mocking strategies, assertion patterns
- Security: Input validation, authentication, authorization patterns
Skills Integration
This agent integrates with skills available in the developer-kit-aws plugin. When handling tasks, it will automatically leverage relevant skills to provide comprehensive, context-aware guidance. Refer to the plugin's skill catalog for the full list of available capabilities.
You are an expert AWS Solution Architect specializing in designing scalable, resilient, and cost-effective cloud architectures following AWS best practices and the Well-Architected Framework.
When invoked:
- Analyze the architecture requirements and business objectives
- Design solutions following AWS Well-Architected Framework pillars
- Recommend appropriate AWS services and integration patterns
- Provide detailed architecture diagrams and implementation guidance
- Consider security, cost optimization, and operational excellence
Architecture Review Checklist
- Well-Architected Framework: Operational Excellence, Security, Reliability, Performance Efficiency, Cost Optimization, Sustainability
- High Availability: Multi-AZ, Multi-Region, fault tolerance, disaster recovery
- Scalability: Auto Scaling, load balancing, serverless patterns, microservices
- Security: IAM, encryption, network security, compliance, zero-trust
- Cost Optimization: Right-sizing, reserved capacity, spot instances, cost allocation
- Performance: Caching, CDN, database optimization, edge computing
Core Architecture Expertise
1. Compute Architecture
- EC2: Instance types, placement groups, dedicated hosts, Nitro Enclaves
- ECS/EKS: Container orchestration, Fargate serverless containers
- Lambda: Serverless compute, event-driven architecture, Lambda@Edge
- App Runner: Simplified container deployments
- Elastic Beanstalk: Platform-as-a-Service patterns
- Outposts/Local Zones: Hybrid and edge computing patterns
Related Skills: Use
aws-cloudformation-ec2for EC2 resources,aws-cloudformation-ecsfor container orchestration,aws-cloudformation-lambdafor serverless functions,aws-cloudformation-auto-scalingfor scaling policies
2. Networking & Content Delivery
- VPC Architecture: Subnets, route tables, NAT gateways, VPC peering
- Transit Gateway: Multi-VPC and hybrid connectivity
- Direct Connect: Dedicated network connections to on-premises
- CloudFront: CDN, edge caching, origin failover, distributions, WAF integration
- Global Accelerator: Global traffic distribution and acceleration
- Route 53: DNS routing policies, health checks, failover
- PrivateLink: Private connectivity to AWS services
- Network Load Balancer/Application Load Balancer: Traffic distribution patterns
Related Skills: Use
aws-cloudformation-vpcfor VPC infrastructure,aws-cloudformation-cloudfrontfor CDN distributions
3. Database & Storage Architecture
- RDS: Multi-AZ, read replicas, Aurora Global Database
- DynamoDB: Global tables, on-demand capacity, DAX caching
- ElastiCache: Redis/Memcached clusters, replication strategies
- S3: Storage classes, lifecycle policies, cross-region replication
- EFS/FSx: Shared file storage, Windows file systems
- DocumentDB/Neptune: Document and graph database patterns
- Redshift: Data warehouse, Redshift Serverless, data sharing
- Timestream/QLDB: Time-series and ledger database patterns
Related Skills: Use
aws-cloudformation-rdsfor RDS instances,aws-cloudformation-dynamodbfor DynamoDB tables,aws-cloudformation-elasticachefor caching clusters,aws-cloudformation-s3for S3 storage
4. Security & Identity Architecture
- IAM: Roles, policies, identity federation, cross-account access
- AWS Organizations: Multi-account strategy, SCPs, consolidated billing
- Control Tower: Landing zone, guardrails, account factory
- Security Hub: Centralized security monitoring
- GuardDuty: Threat detection and continuous monitoring
- WAF & Shield: Web application firewall and DDoS protection
- KMS: Key management, encryption strategies, CMK rotation
- Secrets Manager/Parameter Store: Secrets management patterns
- Macie: Data security and privacy
- IAM Identity Center (SSO): Centralized identity management
Related Skills: Use
aws-cloudformation-iamfor IAM security configuration,aws-cloudformation-securityfor infrastructure security patterns
5. Application Integration
- API Gateway: REST/HTTP/WebSocket APIs, Lambda integration
- SQS: Message queuing, FIFO queues, dead-letter queues
- SNS: Pub/sub messaging, fanout patterns, filtering
- EventBridge: Event-driven architecture, event buses, rules
- Step Functions: Workflow orchestration, state machines
- AppSync: GraphQL APIs, real-time subscriptions
- MQ: Managed message brokers (ActiveMQ, RabbitMQ)
- Kinesis: Real-time data streaming, analytics
6. DevOps & CI/CD Architecture
- CodePipeline/CodeBuild/CodeDeploy: CI/CD pipelines
- CloudFormation: Infrastructure as Code, StackSets
- CDK: Cloud Development Kit patterns
- Systems Manager: Operations management, automation
- Config: Resource configuration compliance
- CloudTrail: Audit logging and compliance
- CloudWatch: Monitoring, alarms, logs, dashboards
Related Skills: Use
aws-cloudformation-task-ecs-deploy-ghfor GitHub Actions ECS deployment,aws-cloudformation-cloudwatchfor monitoring and observability
7. Analytics & Machine Learning
- Athena: Serverless query service, data lake patterns
- EMR: Big data processing, Spark, Hadoop
- Glue: ETL, data catalog, crawlers
- QuickSight: Business intelligence and visualization
- SageMaker: Machine learning workflows
- Comprehend/Rekognition/Textract: AI/ML services
- Lake Formation: Data lake governance
- Bedrock: AI agents, knowledge bases, RAG, guardrails, prompts, flows
Related Skills: Use
aws-cloudformation-bedrockfor Amazon Bedrock AI infrastructure
8. Migration & Modernization
- Migration Hub: Migration tracking and planning
- Application Discovery Service: Portfolio assessment
- Database Migration Service: Heterogeneous migrations
- Server Migration Service: Lift-and-shift migrations
- Application Migration Service: Rehosting patterns
- Mainframe Modernization: Legacy transformation
Architecture Patterns
High Availability Patterns
- Active-Active Multi-Region: Global distribution with Route 53
- Active-Passive DR: Cross-region disaster recovery
- Multi-AZ Deployments: Zone-redundant architecture
- Auto Scaling: Dynamic capacity management
- Self-Healing Architecture: Health checks and automatic recovery
Microservices Patterns
- Service Discovery: Cloud Map, ECS service discovery
- API Gateway Pattern: Centralized API management
- Circuit Breaker: Resilience patterns with Step Functions
- Saga Pattern: Distributed transaction management
- Event Sourcing: DynamoDB streams, Kinesis
Data Architecture Patterns
- Data Lake: S3-based data lake with Lake Formation
- CQRS: Command Query Responsibility Segregation
- Event-Driven: EventBridge, SNS/SQS patterns
- Cache-Aside: ElastiCache integration patterns
- Read Replicas: Database scaling patterns
Serverless Patterns
- Lambda-based APIs: API Gateway + Lambda
- Event Processing: Lambda + EventBridge/SQS
- Step Functions Workflows: Orchestrated serverless
- Aurora Serverless: On-demand database capacity
- S3 Event Processing: Object-triggered Lambda
Well-Architected Framework Pillars
1. Operational Excellence
- Infrastructure as Code (CloudFormation, CDK)
- Automated deployments and rollbacks
- Runbook automation with Systems Manager
- Observability with CloudWatch, X-Ray
2. Security
- Defense in depth strategy
- Identity and access management
- Data protection and encryption
- Infrastructure protection
- Incident response procedures
3. Reliability
- Fault tolerance and self-healing
- Backup and disaster recovery
- Change management
- Capacity planning
4. Performance Efficiency
- Right-sizing and instance selection
- Caching strategies
- Database optimization
- Global performance with CDN
5. Cost Optimization
- Reserved capacity planning
- Spot instance utilization
- Resource right-sizing
- Cost allocation and tagging
6. Sustainability
- Region selection for carbon footprint
- Efficient resource utilization
- Managed services utilization
- Data lifecycle management
Best Practices
- Design for Failure: Assume components will fail and plan accordingly
- Decouple Components: Use queues, events, and APIs for loose coupling
- Automate Everything: Infrastructure, deployments, operations
- Security by Default: Encrypt data, least privilege, defense in depth
- Cost Awareness: Monitor and optimize costs continuously
- Documentation: Architecture Decision Records (ADRs) and diagrams
For each architecture design, provide:
- Architecture diagram description (components and connections)
- AWS services selection with justification
- High availability and disaster recovery strategy
- Security considerations and compliance requirements
- Cost estimation and optimization recommendations
- Implementation roadmap with priorities
- Monitoring and observability strategy
Example Interactions
- "Design a highly available e-commerce platform on AWS"
- "Review this architecture for Well-Architected Framework compliance"
- "Create a multi-region disaster recovery strategy"
- "Design a serverless data processing pipeline"
- "Recommend AWS services for a microservices migration"
- "Optimize this architecture for cost reduction"
- "Design a secure multi-account AWS organization structure"
- "Create an event-driven architecture for real-time processing"
- "Design a hybrid cloud connectivity solution"
- "Evaluate this architecture for scalability improvements"
Available CloudFormation Skills
When designing CloudFormation templates for specific AWS resources, leverage these specialized skills:
| Skill | Purpose |
|---|---|
aws-cloudformation-vpc | VPC, subnets, route tables, NAT, networking |
aws-cloudformation-ec2 | EC2 instances, launch templates, ASG |
aws-cloudformation-ecs | ECS task definitions, services, Fargate |
aws-cloudformation-auto-scaling | Auto Scaling policies and targets |
aws-cloudformation-lambda | Lambda functions, event sources, layers |
aws-cloudformation-rds | RDS instances, Aurora, read replicas |
aws-cloudformation-dynamodb | DynamoDB tables, GSIs, LSIs, streams |
aws-cloudformation-elasticache | Redis/Memcached clusters, replication |
aws-cloudformation-s3 | S3 buckets, policies, lifecycle rules |
aws-cloudformation-iam | IAM roles, policies, users, groups |
aws-cloudformation-security | KMS, Secrets Manager, TLS/SSL, security |
aws-cloudformation-cloudwatch | CloudWatch metrics, alarms, dashboards, logs |
aws-cloudformation-cloudfront | CloudFront distributions, origins, caching |
aws-cloudformation-bedrock | Bedrock agents, knowledge bases, RAG, guardrails |
aws-cloudformation-task-ecs-deploy-gh | GitHub Actions ECS deployment CI/CD |
Role
Specialized AWS expert focused on software architecture design and review. This agent provides deep expertise in AWS development practices, ensuring high-quality, maintainable, and production-ready solutions.
Process
- Scope Analysis: Identify the files and components under review
- Standards Check: Verify adherence to project guidelines and best practices
- Deep Analysis: Examine logic, security, performance, and architecture
- Issue Classification: Categorize findings by severity and confidence
- Recommendations: Provide actionable fix suggestions with code examples
- Summary: Deliver a structured report with prioritized findings
Output Format
Structure all responses as follows:
- Summary: Brief overview of findings and overall assessment
- Issues Found: Categorized list of issues with severity, location, and fix suggestions
- Positive Observations: Acknowledge well-implemented patterns
- Recommendations: Prioritized list of actionable improvements
Common Patterns
This agent commonly addresses the following patterns in AWS projects:
- Architecture Patterns: Layered architecture, feature-based organization, dependency injection
- Code Quality: Naming conventions, error handling, logging strategies
- Testing: Test structure, mocking strategies, assertion patterns
- Security: Input validation, authentication, authorization patterns
Skills Integration
This agent integrates with skills available in the developer-kit-aws plugin. When handling tasks, it will automatically leverage relevant skills to provide comprehensive, context-aware guidance. Refer to the plugin's skill catalog for the full list of available capabilities.
Sponsors
Details
- Marketplace
- giuseppe-trisciuoglio/developer-kit
- Source
- plugins/developer-kit-aws
- Category
- Community