Amazon Q Developer in Practice: Revolutionizing Development with AI

# Install Amazon Q extension
code --install-extension amazonwebservices.amazon-q-vscode

# Configure AWS CLI
aws configure

# Or use AWS SSO
aws configure sso

import json
import boto3
from datetime import datetime

def lambda_handler(event, context):
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('ProcessedMessages')
    
    for record in event['Records']:
        # Process SQS message
        message_body = json.loads(record['body'])
        
        # Save to DynamoDB
        table.put_item(
            Item={
                'id': record['messageId'],
                'message': message_body,
                'processed_at': datetime.utcnow().isoformat(),
                'source_queue': record['eventSourceARN']
            }
        )
    
    return {
        'statusCode': 200,
        'body': json.dumps('Messages processed successfully')
    }

# Main VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true
  
  tags = {
    Name = "main-vpc"
  }
}

# Internet Gateway
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id
  
  tags = {
    Name = "main-igw"
  }
}

# Public Subnets
resource "aws_subnet" "public" {
  count             = 2
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 1}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]
  
  map_public_ip_on_launch = true
  
  tags = {
    Name = "public-subnet-${count.index + 1}"
    Type = "Public"
  }
}

# Private Subnets
resource "aws_subnet" "private" {
  count             = 2
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 10}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]
  
  tags = {
    Name = "private-subnet-${count.index + 1}"
    Type = "Private"
  }
}

# Public Route Table
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id
  
  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main.id
  }
  
  tags = {
    Name = "public-rt"
  }
}

# Public Route Table Association
resource "aws_route_table_association" "public" {
  count          = length(aws_subnet.public)
  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}

data "aws_availability_zones" "available" {
  state = "available"
}

def process_data(data):
    result = []
    for item in data:
        if item['status'] == 'active':
            result.append(item)
    return result

def process_data(data):
    """Filter active items more efficiently"""
    return [item for item in data if item.get('status') == 'active']

# 1. Check CloudWatch logs
aws logs describe-log-groups --log-group-name-prefix "/aws/lambda/your-function"

# 2. Analyze metrics
aws cloudwatch get-metric-statistics \
  --namespace AWS/Lambda \
  --metric-name Duration \
  --dimensions Name=FunctionName,Value=your-function \
  --start-time 2025-01-01T00:00:00Z \
  --end-time 2025-01-02T00:00:00Z \
  --period 300 \
  --statistics Average,Maximum

# 3. Check timeout configuration
aws lambda get-function-configuration --function-name your-function

name: Deploy with Amazon Q Optimization
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v2
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-east-1
      
      - name: Amazon Q Code Review
        run: |
          # Use Amazon Q to review code before deploy
          echo "Running analysis with Amazon Q..."
          
      - name: Deploy to AWS
        run: |
          aws cloudformation deploy \
            --template-file template.yaml \
            --stack-name my-app \
            --capabilities CAPABILITY_IAM

# Optimized configuration suggested by Amazon Q
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  
  # Backend optimized for collaboration
  backend "s3" {
    bucket         = "terraform-state-bucket"
    key            = "infrastructure/terraform.tfstate"
    region         = "us-east-1"
    encrypt        = true
    dynamodb_table = "terraform-locks"
  }
}

# Provider with performance settings
provider "aws" {
  region = var.aws_region
  
  default_tags {
    tags = {
      Environment = var.environment
      Project     = var.project_name
      ManagedBy   = "Terraform"
      CreatedBy   = "AmazonQ"
    }
  }
}

{
  "widgets": [
    {
      "type": "metric",
      "properties": {
        "metrics": [
          ["AWS/Lambda", "Duration", "FunctionName", "my-function"],
          [".", "Errors", ".", "."],
          [".", "Invocations", ".", "."]
        ],
        "period": 300,
        "stat": "Average",
        "region": "us-east-1",
        "title": "Lambda Performance Metrics"
      }
    }
  ]
}

# CloudFormation for optimized alerts
Resources:
  HighErrorRateAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: Lambda-HighErrorRate
      AlarmDescription: "Alert when error rate exceeds 5%"
      MetricName: ErrorRate
      Namespace: AWS/Lambda
      Statistic: Average
      Period: 300
      EvaluationPeriods: 2
      Threshold: 5
      ComparisonOperator: GreaterThanThreshold
      Dimensions:
        - Name: FunctionName
          Value: !Ref MyLambdaFunction
      AlarmActions:
        - !Ref SNSTopicArn

# Script generated by Q for cost analysis
import boto3
from datetime import datetime, timedelta

def analyze_costs():
    ce_client = boto3.client('ce')
    
    end_date = datetime.now().strftime('%Y-%m-%d')
    start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
    
    response = ce_client.get_cost_and_usage(
        TimePeriod={
            'Start': start_date,
            'End': end_date
        },
        Granularity='DAILY',
        Metrics=['BlendedCost'],
        GroupBy=[
            {
                'Type': 'DIMENSION',
                'Key': 'SERVICE'
            }
        ]
    )
    
    # Analyze and suggest optimizations
    for result in response['ResultsByTime']:
        for group in result['Groups']:
            service = group['Keys'][0]
            cost = float(group['Metrics']['BlendedCost']['Amount'])
            
            if cost > 100:  # High-cost services
                print(f"⚠️ {service}: ${cost:.2f} - Review optimizations")

# Automated security check
import boto3

def security_audit():
    ec2 = boto3.client('ec2')
    
    # Check Security Groups
    sgs = ec2.describe_security_groups()
    
    for sg in sgs['SecurityGroups']:
        for rule in sg['IpPermissions']:
            for ip_range in rule.get('IpRanges', []):
                if ip_range.get('CidrIp') == '0.0.0.0/0':
                    print(f"🚨 Security Group {sg['GroupId']} allows public access")
                    
    # Check instances without tags
    instances = ec2.describe_instances()
    for reservation in instances['Reservations']:
        for instance in reservation['Instances']:
            if not instance.get('Tags'):
                print(f"⚠️ Instance {instance['InstanceId']} has no tags")

❌ Bad: "Create an API"
✅ Good: "Create a REST API in Python using FastAPI to manage users, with CRUD endpoints, data validation, and DynamoDB integration"

❌ Generic: "How to deploy?"
✅ Specific: "How to deploy a Node.js application on ECS Fargate using GitHub Actions, with automatic rollback on failure?"

1. Initial prompt: "Create a Lambda function to process images"
2. Refinement: "Add automatic resizing"
3. Optimization: "Implement caching with ElastiCache"
4. Security: "Add file type validation"

# Productivity metrics with Amazon Q
metrics = {
    "time_to_deploy": "Average deploy time",
    "code_quality_score": "Code quality score",
    "infrastructure_efficiency": "Infrastructure efficiency",
    "cost_optimization": "AWS cost optimization",
    "incident_resolution_time": "Incident resolution time"
}