The $400,000 CPU Mistake

#!/usr/bin/env python3
# find_arm_opportunities.py

import boto3
import json
from datetime import datetime

ec2 = boto3.client('ec2')

# Instance type mapping
INTEL_TO_ARM = {
    't3.nano': 't4g.nano',
    't3.micro': 't4g.micro',
    't3.small': 't4g.small',
    't3.medium': 't4g.medium',
    't3.large': 't4g.large',
    't3.xlarge': 't4g.xlarge',
    't3.2xlarge': 't4g.2xlarge',
    'm5.large': 'm6g.large',
    'm5.xlarge': 'm6g.xlarge',
    'm5.2xlarge': 'm6g.2xlarge',
    'm5.4xlarge': 'm6g.4xlarge',
    'c5.large': 'c6g.large',
    'c5.xlarge': 'c6g.xlarge',
    'c5.2xlarge': 'c6g.2xlarge',
    'r5.large': 'r6g.large',
    'r5.xlarge': 'r6g.xlarge',
    'r5.2xlarge': 'r6g.2xlarge',
}

# Hourly prices (update for your region)
HOURLY_PRICES = {
    't3.micro': 0.0104,
    't3.small': 0.0208,
    't3.medium': 0.0416,
    't3.large': 0.0832,
    't3.xlarge': 0.1664,
    'm5.large': 0.096,
    'm5.xlarge': 0.192,
    'm5.2xlarge': 0.384,
    'c5.large': 0.085,
    'c5.xlarge': 0.17,
    'r5.large': 0.126,
    'r5.xlarge': 0.252,
}

def find_intel_instances():
    """Find all running Intel instances that could move to ARM"""
    
    response = ec2.describe_instances(
        Filters=[
            {'Name': 'instance-state-name', 'Values': ['running']}
        ]
    )
    
    intel_instances = []
    
    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            instance_type = instance['InstanceType']
            
            if instance_type in INTEL_TO_ARM:
                # Get instance name from tags
                name = 'No Name'
                for tag in instance.get('Tags', []):
                    if tag['Key'] == 'Name':
                        name = tag['Value']
                        break
                
                intel_instances.append({
                    'id': instance['InstanceId'],
                    'name': name,
                    'type': instance_type,
                    'arm_type': INTEL_TO_ARM[instance_type],
                    'launch_time': instance['LaunchTime'].strftime('%Y-%m-%d')
                })
    
    return intel_instances

def calculate_savings(instances):
    """Calculate potential savings from ARM migration"""
    
    total_monthly_intel = 0
    total_monthly_arm = 0
    
    print("\n" + "="*70)
    print("ARM MIGRATION OPPORTUNITY REPORT")
    print("="*70)
    print(f"Found {len(instances)} Intel instances that can migrate to ARM")
    print("-"*70)
    
    # Group by instance type
    by_type = {}
    for inst in instances:
        if inst['type'] not in by_type:
            by_type[inst['type']] = []
        by_type[inst['type']].append(inst)
    
    print("\nBY INSTANCE TYPE:")
    for itype, insts in sorted(by_type.items()):
        count = len(insts)
        hourly = HOURLY_PRICES.get(itype, 0.10)
        monthly_intel = hourly * 24 * 30 * count
        monthly_arm = monthly_intel * 0.8  # 20% savings
        savings = monthly_intel - monthly_arm
        
        total_monthly_intel += monthly_intel
        total_monthly_arm += monthly_arm
        
        print(f"\n  {itype} → {INTEL_TO_ARM[itype]}")
        print(f"    Count: {count} instances")
        print(f"    Current cost: ${monthly_intel:,.2f}/month")
        print(f"    ARM cost: ${monthly_arm:,.2f}/month")
        print(f"    Savings: ${savings:,.2f}/month (${savings*12:,.2f}/year)")
    
    print("\n" + "="*70)
    print("TOTAL SAVINGS SUMMARY:")
    print(f"  Current Intel cost: ${total_monthly_intel:,.2f}/month")
    print(f"  Projected ARM cost: ${total_monthly_arm:,.2f}/month")
    print(f"  Monthly savings: ${total_monthly_intel - total_monthly_arm:,.2f}")
    print(f"  Annual savings: ${(total_monthly_intel - total_monthly_arm) * 12:,.2f}")
    print("="*70)
    
    # Export to CSV
    print("\nDETAILED INSTANCE LIST:")
    print(f"{'Instance ID':<20} {'Name':<30} {'Type':<12} {'ARM Type':<12}")
    print("-"*74)
    for inst in instances:
        print(f"{inst['id']:<20} {inst['name'][:29]:<30} {inst['type']:<12} {inst['arm_type']:<12}")
    
    return total_monthly_intel - total_monthly_arm

if __name__ == "__main__":
    instances = find_intel_instances()
    
    if instances:
        monthly_savings = calculate_savings(instances)
        
        # Save to file
        with open('arm_migration_plan.json', 'w') as f:
            json.dump(instances, f, indent=2, default=str)
        
        print(f"\n✅ Full report saved to arm_migration_plan.json")
        print(f"\n💰 Start with the largest instance type for maximum impact!")
    else:
        print("No Intel instances found that can migrate to ARM")

#!/bin/bash
# test-arm.sh - Run this right now to test ARM

# Get your current instance details
INSTANCE_ID="i-0abc123def456"  # <- Replace with your instance ID
REGION="us-east-1"

echo "🔍 Getting current instance info..."
CURRENT_TYPE=$(aws ec2 describe-instances \
  --instance-ids $INSTANCE_ID \
  --query 'Reservations[0].Instances[0].InstanceType' \
  --output text)

CURRENT_AMI=$(aws ec2 describe-instances \
  --instance-ids $INSTANCE_ID \
  --query 'Reservations[0].Instances[0].ImageId' \
  --output text)

# Map Intel to ARM instance types
case $CURRENT_TYPE in
  t3.micro)   ARM_TYPE="t4g.micro" ;;
  t3.small)   ARM_TYPE="t4g.small" ;;
  t3.medium)  ARM_TYPE="t4g.medium" ;;
  t3.large)   ARM_TYPE="t4g.large" ;;
  m5.large)   ARM_TYPE="m6g.large" ;;
  m5.xlarge)  ARM_TYPE="m6g.xlarge" ;;
  c5.large)   ARM_TYPE="c6g.large" ;;
  c5.xlarge)  ARM_TYPE="c6g.xlarge" ;;
  *) echo "❌ No ARM equivalent for $CURRENT_TYPE"; exit 1 ;;
esac

# Get ARM AMI (Amazon Linux 2)
ARM_AMI=$(aws ssm get-parameter \
  --name /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-arm64-gp2 \
  --query 'Parameter.Value' --output text)

echo "✅ Launching ARM test instance ($ARM_TYPE)..."

# Launch ARM twin
aws ec2 run-instances \
  --image-id $ARM_AMI \
  --instance-type $ARM_TYPE \
  --key-name your-key-name \
  --security-group-ids sg-yourgroup \
  --subnet-id subnet-yoursub \
  --tag-specifications "ResourceType=instance,Tags=[{Key=Name,Value=ARM-TEST-$CURRENT_TYPE}]" \
  --output table

echo "🚀 ARM instance launched! SSH in and run performance tests."

#!/bin/bash
# check-compatibility.sh - Will my app work on ARM?

echo "🔍 Checking ARM compatibility..."

# Check architecture of all binaries in current directory
for file in $(find /usr/local/bin /opt -type f -executable 2>/dev/null | head -20); do
  if file "$file" | grep -q "x86-64"; then
    echo "❌ x86-only: $file"
  elif file "$file" | grep -q "ARM\|aarch64"; then  
    echo "✅ ARM ready: $file"
  fi
done

# Check Docker images
if [ -f docker-compose.yml ]; then
  echo -e "\n📦 Docker images:"
  grep "image:" docker-compose.yml | while read -r line; do
    IMAGE=$(echo $line | cut -d: -f2- | xargs)
    if docker manifest inspect $IMAGE 2>/dev/null | grep -q "arm64"; then
      echo "✅ $IMAGE supports ARM"
    else
      echo "❌ $IMAGE is x86-only"
    fi
  done
fi

# Check package managers
echo -e "\n📚 Package managers:"
command -v python3 && echo "✅ Python works on ARM"
command -v node && echo "✅ Node.js works on ARM"  
command -v java && echo "✅ Java works on ARM"

# Dockerfile - Works on both Intel and ARM
FROM --platform=$BUILDPLATFORM node:16-alpine AS builder
ARG TARGETARCH

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM --platform=$TARGETPLATFORM node:16-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 8080
CMD ["node", "dist/index.js"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-arm
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
      arch: arm64
  template:
    metadata:
      labels:
        app: myapp
        arch: arm64
    spec:
      nodeSelector:
        kubernetes.io/arch: arm64  # Force ARM nodes
      containers:
      - name: app
        image: myapp:latest-arm64
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
---
# Service that works with both architectures
apiVersion: v1
kind: Service
metadata:
  name: myapp
spec:
  selector:
    app: myapp  # Matches both ARM and Intel pods
  ports:
  - port: 80
    targetPort: 8080

#!/bin/bash
# migrate-rds-to-arm.sh

DB_INSTANCE="mydb-dev"
NEW_INSTANCE="mydb-dev-arm"
INSTANCE_TYPE="db.r6g.xlarge"

echo "📊 Current RDS instance details:"
aws rds describe-db-instances \
  --db-instance-identifier $DB_INSTANCE \
  --query 'DBInstances[0].[DBInstanceClass,Engine,EngineVersion]' \
  --output table

echo "🔄 Creating ARM read replica..."
aws rds create-db-instance-read-replica \
  --db-instance-identifier $NEW_INSTANCE \
  --source-db-instance-identifier $DB_INSTANCE \
  --db-instance-class $INSTANCE_TYPE  # Graviton2 instance

echo "⏳ Waiting for replica to be available..."
aws rds wait db-instance-available \
  --db-instance-identifier $NEW_INSTANCE

echo "📈 Promoting replica to master..."
aws rds promote-read-replica \
  --db-instance-identifier $NEW_INSTANCE

echo "✅ Migration complete! Update your connection strings to: $NEW_INSTANCE"