Amazon Q Developer na Prática: Revolucionando o Desenvolvimento com IA

# Instalar extensão Amazon Q
code --install-extension amazonwebservices.amazon-q-vscode

# Configurar AWS CLI
aws configure

# Ou usar 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']:
        # Processar mensagem SQS
        message_body = json.loads(record['body'])
        
        # Salvar no 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')
    }

# VPC Principal
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"
  }
}

# Subnets Públicas
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"
  }
}

# Subnets Privadas
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"
  }
}

# Route Table Pública
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"
  }
}

# Associação Route Table Pública
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):
    """Filtra itens ativos de forma mais eficiente"""
    return [item for item in data if item.get('status') == 'active']

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

# 2. Analisar métricas
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. Verificar configuração de timeout
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: |
          # Usar Amazon Q para revisar código antes do deploy
          echo "Executando análise com Amazon Q..."
          
      - name: Deploy to AWS
        run: |
          aws cloudformation deploy \
            --template-file template.yaml \
            --stack-name my-app \
            --capabilities CAPABILITY_IAM

# Configuração otimizada sugerida pelo Amazon Q
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  
  # Backend otimizado para colaboração
  backend "s3" {
    bucket         = "terraform-state-bucket"
    key            = "infrastructure/terraform.tfstate"
    region         = "us-east-1"
    encrypt        = true
    dynamodb_table = "terraform-locks"
  }
}

# Provider com configurações de performance
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 para alertas otimizados
Resources:
  HighErrorRateAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: Lambda-HighErrorRate
      AlarmDescription: "Alerta quando taxa de erro excede 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 gerado pelo Q para análise de custos
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'
            }
        ]
    )
    
    # Analisar e sugerir otimizações
    for result in response['ResultsByTime']:
        for group in result['Groups']:
            service = group['Keys'][0]
            cost = float(group['Metrics']['BlendedCost']['Amount'])
            
            if cost > 100:  # Serviços com custo alto
                print(f"⚠️ {service}: ${cost:.2f} - Revisar otimizações")

# Verificação de segurança automatizada
import boto3

def security_audit():
    ec2 = boto3.client('ec2')
    
    # Verificar 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']} permite acesso público")
                    
    # Verificar instâncias sem tags
    instances = ec2.describe_instances()
    for reservation in instances['Reservations']:
        for instance in reservation['Instances']:
            if not instance.get('Tags'):
                print(f"⚠️ Instância {instance['InstanceId']} sem tags")

❌ Ruim: "Crie uma API"
✅ Bom: "Crie uma API REST em Python usando FastAPI para gerenciar usuários, com endpoints CRUD, validação de dados e integração com DynamoDB"

❌ Genérico: "Como fazer deploy?"
✅ Específico: "Como fazer deploy de aplicação Node.js no ECS Fargate usando GitHub Actions, com rollback automático em caso de falha?"

1. Prompt inicial: "Crie função Lambda para processar imagens"
2. Refinamento: "Adicione redimensionamento automático"
3. Otimização: "Implemente cache com ElastiCache"
4. Segurança: "Adicione validação de tipos de arquivo"

# Métricas de produtividade com Amazon Q
metrics = {
    "time_to_deploy": "Tempo médio de deploy",
    "code_quality_score": "Score de qualidade do código",
    "infrastructure_efficiency": "Eficiência da infraestrutura",
    "cost_optimization": "Otimização de custos AWS",
    "incident_resolution_time": "Tempo de resolução de incidentes"
}