🔧 AWS Troubleshooting Interview

Comprehensive interview preparation for troubleshooting, debugging, and problem-solving on AWS data services.

Module: AWS Data Engineering • Topic 58 of 65 • Premium Content

Troubleshooting Framework

Architecture Diagram

┌─────────────────────────────────────────────────────────────────────┐
│                    AWS Troubleshooting Framework                    │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Identify             Diagnose            Resolve                 │
│  ┌──────────────┐     ┌──────────────┐    ┌──────────────┐       │
│  │ Symptoms     │────▶│ Root Cause   │───▶│ Fix          │       │
│  │ Logs         │     │ Analysis     │    │ Prevent      │       │
│  │ Metrics      │     │ Testing      │    │ Monitor      │       │
│  └──────────────┘     └──────────────┘    └──────────────┘       │
│                                                                     │
│  Common Areas                                                    │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ • Performance (slow queries, high latency)                │   │
│  │ • Connectivity (network, IAM, permissions)                │   │
│  │ • Data (corruption, duplication, missing)                 │   │
│  │ • Cost (unexpected charges, optimization)                 │   │
│  │ • Security (access denied, compliance)                    │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Q1: How do you troubleshoot slow Athena queries?

Answer:

Slow Query Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Slow Athena Query Diagnosis                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Query Statistics                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ SELECT * FROM system.query_history                      │   │
│  │ WHERE query_id = 'your-query-id'                       │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • Data scanned vs data returned                        │   │
│  │ • Execution time breakdown                             │   │
│  │ • Bytes scanned                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Analyze Query Plan                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ EXPLAIN (FORMAT=GRAPHVIZ) SELECT ...                    │   │
│  │                                                          │   │
│  │ Look for:                                               │   │
│  │ • Full table scans (no partition pruning)              │   │
│  │ • Large intermediate results                           │   │
│  │ • Skewed joins                                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Check Data Layout                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • File sizes (small files = overhead)                  │   │
│  │ • Partition pruning (WHERE clause on partition columns)│   │
│  │ • Column pruning (SELECT specific columns)             │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Common Fixes:

-- Problem: Full table scan
-- Before: 100GB scanned, 5 minutes
SELECT * FROM events WHERE event_date = '2024-01-15';

-- After: 2.7GB scanned, 10 seconds (with partitioning)
SELECT * FROM events 
WHERE year = 2024 AND month = 1 AND day = 15;

-- Problem: SELECT * scans all columns
-- Before: 100GB scanned
SELECT * FROM events;

-- After: 5GB scanned (column pruning)
SELECT event_id, event_time, event_type FROM events;

Q2: How do you troubleshoot EMR cluster failures?

Answer:

EMR Troubleshooting Checklist:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              EMR Cluster Failure Diagnosis                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Cluster Status                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ aws emr describe-cluster --cluster-id j-XXXXXXXXX       │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • ClusterStatus.State                                   │   │
│  │ • NormalizedInstanceHours                               │   │
│  │ • Ec2InstanceAttributes                                 │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check Step Status                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ aws emr list-steps --cluster-id j-XXXXXXXXX             │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • StepState                                             │   │
│  │ • FailureDetails                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Check Logs                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ s3://my-bucket/j-XXXXXXXXX/logs/                       │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • instance-controller.log                              │   │
│  │ • spark-history/                                        │   │
│  │ • hive-server2/                                         │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Common Issues & Solutions:

# Issue 1: Spot instance interruption
# Solution: Use On-Demand or handle interruption
def handle_spot_interruption():
    # Check for interruption notice
    response = requests.get(
        'http://169.254.169.254/latest/meta-data/spot/instance-action',
        headers={'X-aws-ec2-metadata-token': get_token()}
    )
    
    if response.status_code == 200:
        # Save state and prepare for termination
        save_checkpoint()
        upload_to_s3()

# Issue 2: OutOfMemoryError
# Solution: Increase executor memory
spark.conf.set('spark.executor.memory', '8g')
spark.conf.set('spark.driver.memory', '4g')

# Issue 3: Slow shuffle
# Solution: Optimize shuffle partitions
spark.conf.set('spark.sql.shuffle.partitions', '200')

Q3: How do you troubleshoot Redshift query performance?

Answer:

Redshift Performance Diagnosis:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Redshift Query Performance Diagnosis               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Query Execution                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ SELECT query, records, elapsed, bytes                   │   │
│  │ FROM stl_query                                          │   │
│  │ WHERE query = [your-query-id]                           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Analyze Query Plan                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ EXPLAIN SELECT ...                                      │   │
│  │                                                          │   │
│  │ Look for:                                               │   │
│  │ • Nested loop vs hash join                             │   │
│  │ • Data distribution errors                             │   │
│  │ • Sort key usage                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Check Table Statistics                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ SELECT * FROM svv_table_info                           │   │
│  │ WHERE table = 'your_table'                             │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • skew_sortkey1                                         │   │
│  │ • skew_rows                                             │   │
│  │ • unsorted                                              │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Performance Tuning:

-- Check for data skew
SELECT 
    t.table_name,
    t.skew_sortkey1,
    t.skew_rows
FROM svv_table_info t
WHERE t.database = 'analytics'
ORDER BY t.skew_rows DESC;

-- Optimize distribution
ALTER TABLE fact_sales DISTSTYLE KEY DISTKEY(customer_id);

-- Add sort key
ALTER TABLE fact_sales SORTKEY(sale_date, customer_id);

-- Vacuum and analyze
VACUUM SORT ONLY fact_sales;
ANALYZE fact_sales;

Q4: How do you troubleshoot Glue job failures?

Answer:

Glue Job Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Glue Job Failure Diagnosis                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Job Status                                      │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ aws glue get-job-run --job-name my-job --run-id r-XXX   │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • JobRunState                                           │   │
│  │ • ExecutionTime                                         │   │
│  │ • ErrorMessage                                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check CloudWatch Logs                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ /aws-glue/jobs/errors                                   │   │
│  │                                                          │   │
│  │ Look for:                                               │   │
│  │ • Python exceptions                                     │   │
│  │ • JVM errors                                            │   │
│  │ • Out of memory                                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Common Issues                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Schema mismatch                                      │   │
│  │ • Permission denied                                     │   │
│  │ • Resource limits exceeded                             │   │
│  │ • Timeout errors                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Common Glue Failures:

# Issue 1: Schema mismatch
# Solution: Use resolveChoice
from awsglue.transforms import ResolveChoice

resolvechoice = ResolveChoice.apply(
    frame=dynamic_frame,
    choice="match_catalog",
    database="mydb",
    table_name="mytable"
)

# Issue 2: Permission denied
# Solution: Check IAM role permissions
# Required policies:
# - AWSGlueServiceRole
# - AmazonS3FullAccess (or specific bucket access)
# - AWSLambdaRole

# Issue 3: Out of memory
# Solution: Increase worker type
# Use G.2X or G.4X workers for large datasets

Q5: How do you troubleshoot Lambda function failures?

Answer:

Lambda Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Lambda Function Failure Diagnosis                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check CloudWatch Logs                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ /aws/lambda/my-function                                 │   │
│  │                                                          │   │
│  │ Look for:                                               │   │
│  │ • START/END markers                                    │   │
│  │ • Error stack traces                                    │   │
│  │ • Timeout warnings                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check Metrics                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ AWS/Lambda namespace                                    │   │
│  │                                                          │   │
│  │ • Invocations                                           │   │
│  │ • Errors                                                │   │
│  │ • Duration                                              │   │
│  │ • Throttles                                             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Common Issues                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Timeout (>3 seconds for API Gateway)                 │   │
│  │ • Memory exceeded                                       │   │
│  │ • Cold start latency                                   │   │
│  │ • Permission errors                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Lambda Optimization:

# Issue 1: Timeout
# Solution: Increase timeout or optimize code
def lambda_handler(event, context):
    # Set context callback
    context.callback_waits_for_final_event = False
    
    # Process asynchronously if > 5 minutes
    # Use Step Functions for long-running tasks

# Issue 2: Cold start
# Solution: Use provisioned concurrency
import boto3
lambda_client = boto3.client('lambda')

lambda_client.put_provisioned_concurrency_config(
    FunctionName='my-function',
    Qualifier='prod',
    ProvisionedConcurrentExecutions=10
)

# Issue 3: Memory exceeded
# Solution: Increase memory (also increases CPU)
# Monitor via CloudWatch:
# Maximum memory used / Allocated memory

Q6: How do you troubleshoot S3 performance issues?

Answer:

S3 Performance Diagnosis:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              S3 Performance Troubleshooting                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Request Metrics                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ s3://my-bucket/?metrics                                │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • Latency (first byte, last byte)                      │   │
│  │ • Errors (4xx, 5xx)                                    │   │
│  │ • Throughput (MB/s)                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check CloudWatch Metrics                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ AWS/S3 namespace                                        │   │
│  │                                                          │   │
│  │ • 4xxErrors                                             │   │
│  │ • 5xxErrors                                             │   │
│  │ • TotalRequests                                         │   │
│  │ • BytesUploaded/Downloaded                             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Common Issues                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • 403 Forbidden: IAM/ACL issues                        │   │
│  │ • 404 Not Found: Wrong key/bucket                      │   │
│  │ • 503 Slow Down: Throttling                            │   │
│  │ • High latency: Too many small files                   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

S3 Optimization:

# Issue 1: Throttling (503 errors)
# Solution: Use exponential backoff
import time
import random

def s3_operation_with_retry(func, max_retries=5):
    for attempt in range(max_retries):
        try:
            return func()
        except ClientError as e:
            if e.response['Error']['Code'] == 'SlowDown':
                time.sleep(2 ** attempt + random.uniform(0, 1))
            else:
                raise

# Issue 2: High latency with small files
# Solution: Use multipart upload or aggregate files
# For Athena, aim for 128MB-1GB files

# Issue 3: Slow listing
# Solution: Use S3 Inventory instead of ListObjectsV2

Q7: How do you troubleshoot network connectivity issues?

Answer:

Network Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Network Connectivity Troubleshooting               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check VPC Configuration                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Security Groups (outbound/inbound rules)             │   │
│  │ • NACLs (subnet-level rules)                           │   │
│  │ • Route Tables (internet/NAT gateway routes)           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check VPC Endpoints                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Gateway endpoints (S3, DynamoDB)                     │   │
│  │ • Interface endpoints (other services)                 │   │
│  │ • Endpoint policies                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Use VPC Flow Logs                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • ACCEPT/REJECT status                                 │   │
│  │ • Source/destination IPs                                │   │
│  │ • Ports and protocols                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Common Network Issues:

# Issue 1: Cannot connect to S3 from VPC
# Solution: Add VPC endpoint
ec2 = boto3.client('ec2')
ec2.create_vpc_endpoint(
    VpcId='vpc-12345678',
    ServiceName='com.amazonaws.us-east-1.s3',
    RouteTableIds=['rtb-12345678']
)

# Issue 2: Security group blocking traffic
# Solution: Add outbound rule
ec2.authorize_security_group_egress(
    GroupId='sg-12345678',
    IpPermissions=[
        {
            'IpProtocol': 'tcp',
            'FromPort': 443,
            'ToPort': 443,
            'IpRanges': [{'CidrIp': '0.0.0.0/0'}]
        }
    ]
)

# Issue 3: NACL blocking ephemeral ports
# Solution: Allow inbound traffic on ports 1024-65535

Q8: How do you troubleshoot IAM permission issues?

Answer:

IAM Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              IAM Permission Troubleshooting                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Use IAM Policy Simulator                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Select user/role                                      │   │
│  │ • Select action (e.g., s3:GetObject)                   │   │
│  │ • Select resource (e.g., arn:aws:s3:::bucket/*)        │   │
│  │ • Check results                                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check Policy Evaluation                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ 1. Explicit Deny → Access denied                       │   │
│  │ 2. No matching Allow → Access denied                   │   │
│  │ 3. Matching Allow → Access allowed                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Common Issues                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Resource policy vs identity policy                   │   │
│  │ • Condition keys (aws:SourceVpc, aws:PrincipalOrgID)  │   │
│  │ • Service control policies (SCPs)                      │   │
│  │ • Permission boundaries                                 │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

IAM Debugging Steps:

# Step 1: Get effective permissions
iam = boto3.client('iam')

# List attached policies
policies = iam.list_attached_user_policies(UserName='user')
for policy in policies['AttachedPolicies']:
    print(policy['PolicyArn'])

# Step 2: Check for explicit denies
# Look for Deny statements in all policies

# Step 3: Use CloudTrail for access denied errors
cloudtrail = boto3.client('cloudtrail')
events = cloudtrail.lookup_events(
    LookupAttributes=[
        {
            'AttributeKey': 'EventName',
            'AttributeValue': 'GetObject'
        }
    ],
    MaxResults=10
)

for event in events['Events']:
    if 'AccessDenied' in event.get('CloudTrailEvent', ''):
        print(event['CloudTrailEvent'])

Q9: How do you troubleshoot data quality issues?

Answer:

Data Quality Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Quality Troubleshooting                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Identify the Issue                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Missing data                                         │   │
│  │ • Duplicate data                                       │   │
│  │ • Invalid formats                                      │   │
│  │ • Schema mismatches                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Trace Data Flow                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Source → Ingestion → Processing → Storage → Query       │   │
│  │                                                          │   │
│  │ Check each stage for:                                   │   │
│  │ • Record counts                                         │   │
│  │ • Data transformation                                  │   │
│  │ • Error handling                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Implement Quality Checks                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Schema validation                                    │   │
│  │ • Null checks                                           │   │
│  │ • Range checks                                          │   │
│  │ • Referential integrity                                │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Quality Check Implementation:

def check_data_quality(df):
    issues = []
    
    # Check for nulls
    null_counts = df.select([
        count(when(col(c).isNull(), c)).alias(c) 
        for c in df.columns
    ]).collect()[0]
    
    for column, count in null_counts.asDict().items():
        if count > 0:
            issues.append(f"NULL values in {column}: {count}")
    
    # Check for duplicates
    total_count = df.count()
    distinct_count = df.distinct().count()
    
    if total_count != distinct_count:
        issues.append(f"Duplicate records: {total_count - distinct_count}")
    
    # Check for invalid values
    if 'amount' in df.columns:
        invalid_amounts = df.filter(col('amount') < 0).count()
        if invalid_amounts > 0:
            issues.append(f"Invalid amounts (negative): {invalid_amounts}")
    
    return issues

Q10: How do you troubleshoot Spark job failures?

Answer:

Spark Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Spark Job Failure Diagnosis                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Spark UI                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Jobs tab: Failed/stuck jobs                          │   │
│  │ • Stages tab: Task failures, shuffle read/write       │   │
│  │ • Storage tab: Cached DataFrames                       │   │
│  │ • Executors tab: Memory usage, GC time                 │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Common Spark Errors                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • OutOfMemoryError: Increase executor memory           │   │
│  │ • Data skew: Salt keys, repartition                    │   │
│  │ • Shuffle overflow: Increase shuffle partitions        │   │
│  │ • Task not serializable: Fix lambda closures           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Check Cluster Resources                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • CPU utilization                                      │   │
│  │ • Memory usage                                         │   │
│  │ • Disk space                                           │   │
│  │ • Network throughput                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Spark Optimization:

# Issue 1: OutOfMemoryError
# Solution: Increase memory or optimize
spark.conf.set('spark.executor.memory', '8g')
spark.conf.set('spark.executor.memoryFraction', '0.8')

# Issue 2: Data skew
# Solution: Salt the skewed key
from pyspark.sql.functions import rand, lit

df_salted = df.withColumn(
    'salt', 
    (rand() * 10).cast('int')
).withColumn(
    'salted_key', 
    concat(col('key'), lit('_'), col('salt'))
)

# Issue 3: Shuffle overflow
# Solution: Increase shuffle partitions
spark.conf.set('spark.sql.shuffle.partitions', '200')

# Issue 4: Task not serializable
# Solution: Use broadcast variables or map-side joins
from pyspark.sql.functions import broadcast
result = large_df.join(broadcast(small_df), 'key')

Q11: How do you troubleshoot Kinesis stream issues?

Answer:

Kinesis Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Kinesis Stream Troubleshooting                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Stream Status                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ aws kinesis describe-stream --stream-name my-stream     │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • StreamStatus (ACTIVE, CREATING, etc.)                │   │
│  │ • ShardCount                                           │   │
│  │ • HasMoreShards                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check CloudWatch Metrics                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ AWS/Kinesis namespace                                   │   │
│  │                                                          │   │
│  │ • GetRecords.IteratorAgeMilliseconds                   │   │
│  │ • PutRecords.Success                                   │   │
│  │ • ReadProvisionedThroughputExceeded                    │   │
│  │ • WriteProvisionedThroughputExceeded                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Common Issues                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Iterator age growing: Consumer too slow              │   │
│  │ • Throttling: Increase shards or use fan-out           │   │
│  │ • Data loss: Check checkpointing                       │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q12: How do you troubleshoot Glue Data Catalog issues?

Answer:

Data Catalog Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Glue Data Catalog Troubleshooting                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Crawler Status                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ aws glue get-crawler --name my-crawler                  │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • CrawlerStatus                                         │   │
│  │ • LastCrawl (Status, ErrorMessage)                     │   │
│  │ • TableCount, ConfigurationVersion                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check Table Schema                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ aws glue get-table --database-name db --table-name tbl │   │
│  │                                                          │   │
│  │ Look at:                                                │   │
│  │ • StorageDescriptor (columns, formats)                 │   │
│  │ • PartitionKeys                                         │   │
│  │ • Parameters (classification, etc.)                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Common Issues                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Schema inference errors                              │   │
│  │ • Missing partitions                                   │   │
│  │ • Incorrect data types                                 │   │
│  │ • Permission issues                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q13: How do you troubleshoot cost anomalies?

Answer:

Cost Anomaly Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Cost Anomaly Troubleshooting                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Identify Anomalous Service                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ aws ce get-cost-and-usage                              │   │
│  │ --time-period Start=2024-01-01,End=2024-01-31          │   │
│  │ --granularity MONTHLY                                   │   │
│  │ --metrics BlendedCost                                   │   │
│  │ --group-by Type=DIMENSION,Key=SERVICE                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Drill Down                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • By region                                            │   │
│  │ • By tag (CostCenter, Environment)                     │   │
│  │ • By instance type                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Common Causes                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Left-over resources (EC2, RDS)                      │   │
│  │ • Data transfer costs                                  │   │
│  │ • Unexpected API calls                                │   │
│  │ • Reserved Instance expiry                            │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Cost Investigation Script:

def investigate_cost_spike():
    ce = boto3.client('ce')
    
    # Get current month costs
    current = ce.get_cost_and_usage(
        TimePeriod={
            'Start': (datetime.now().replace(day=1)).strftime('%Y-%m-%d'),
            'End': datetime.now().strftime('%Y-%m-%d')
        },
        Granularity='MONTHLY',
        Metrics=['BlendedCost'],
        GroupBy=[{'Type': 'DIMENSION', 'Key': 'SERVICE'}]
    )
    
    # Get last month costs for comparison
    last_month_start = (datetime.now().replace(day=1) - timedelta(days=1)).replace(day=1)
    last_month_end = datetime.now().replace(day=1) - timedelta(days=1)
    
    previous = ce.get_cost_and_usage(
        TimePeriod={
            'Start': last_month_start.strftime('%Y-%m-%d'),
            'End': last_month_end.strftime('%Y-%m-%d')
        },
        Granularity='MONTHLY',
        Metrics=['BlendedCost'],
        GroupBy=[{'Type': 'DIMENSION', 'Key': 'SERVICE'}]
    )
    
    # Compare
    for service in current['ResultsByTime'][0]['Groups']:
        service_name = service['Keys'][0]
        current_cost = float(service['Metrics']['BlendedCost']['Amount'])
        
        # Find same service in previous month
        for prev_service in previous['ResultsByTime'][0]['Groups']:
            if prev_service['Keys'][0] == service_name:
                previous_cost = float(prev_service['Metrics']['BlendedCost']['Amount'])
                change = ((current_cost - previous_cost) / previous_cost) * 100
                
                if change > 50:  # More than 50% increase
                    print(f"Anomaly: {service_name} increased {change:.1f}%")

Q14: How do you troubleshoot data replication issues?

Answer:

Replication Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Replication Troubleshooting                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Check Replication Status                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ S3 CRR:                                                 │   │
│  │ aws s3api get-bucket-replication --bucket my-bucket    │   │
│  │                                                          │   │
│  │ RDS Read Replicas:                                      │   │
│  │ aws rds describe-db-instances --db-instance-id replica │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Check CloudWatch Metrics                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • ReplicationLag                                        │   │
│  │ • ReplicatedBytes                                       │   │
│  │ • ReplicationErrors                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Common Issues                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Versioning not enabled                               │   │
│  │ • IAM role permissions                                 │   │
│  │ • Replication rules misconfigured                      │   │
│  │ • Network connectivity                                 │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q15: How do you troubleshoot serverless application issues?

Answer:

Serverless Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Serverless Troubleshooting                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Lambda + API Gateway                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Check Lambda logs in CloudWatch                      │   │
│  │ • Check API Gateway execution logs                     │   │
│  │ • Verify IAM permissions                               │   │
│  │ • Check Lambda configuration (timeout, memory)        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step Functions                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Check execution history                              │   │
│  │ • Review state input/output                            │   │
│  │ • Identify failed state                                │   │
│  │ • Check IAM permissions for each state                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  EventBridge                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Check event rules                                    │   │
│  │ • Verify target permissions                           │   │
│  │ • Review dead-letter queue                             │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q16: How do you troubleshoot security vulnerabilities?

Answer:

Security Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Security Vulnerability Troubleshooting             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Use Security Hub                                      │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Review critical/high findings                        │   │
│  │ • Check compliance status                              │   │
│  │ • Prioritize by severity                               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Use GuardDuty Findings                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • UnauthorizedAccess                                   │   │
│  │ • CryptoCurrency                                       │   │
│  │ • Malware                                              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Remediation                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Patch vulnerabilities                                │   │
│  │ • Update security groups                               │   │
│  │ • Enable encryption                                    │   │
│  │ • Rotate credentials                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q17: How do you troubleshoot slow ETL pipelines?

Answer:

Slow ETL Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Slow ETL Pipeline Troubleshooting                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Identify Bottleneck                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Ingestion → Processing → Loading → Validation          │   │
│  │                                                          │   │
│  │ Measure time at each stage                             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Common Causes                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Small files (too many I/O operations)                │   │
│  │ • Data skew (uneven processing)                        │   │
│  │ • Insufficient resources                               │   │
│  │ • Network latency                                      │   │
│  │ • Serialization overhead                              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Solutions                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • File compaction                                      │   │
│  │ • Partition optimization                               │   │
│  │ • Resource scaling                                     │   │
│  │ • Parallel processing                                  │   │
│  │ • Caching frequent reads                               │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q18: How do you troubleshoot data consistency issues?

Answer:

Data Consistency Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Consistency Troubleshooting                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Common Consistency Issues                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Duplicate records                                    │   │
│  │ • Missing records                                      │   │
│  │ • Out-of-order delivery                                │   │
│  │ • Stale data                                           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Troubleshooting Steps                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ 1. Check source vs destination counts                  │   │
│  │ 2. Verify processing logic (idempotency)              │   │
│  │ 3. Check for late-arriving data                       │   │
│  │ 4. Verify replication lag                              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Prevention Strategies                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Idempotent processing                                │   │
│  │ • Transaction logs                                     │   │
│  │ • Watermarking for late data                           │   │
│  │ • Exactly-once semantics                               │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q19: How do you troubleshoot performance degradation?

Answer:

Performance Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Performance Degradation Troubleshooting            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Establish Baseline                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Historical metrics                                   │   │
│  │ • Expected performance                                 │   │
│  │ • SLA requirements                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Identify Root Cause                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Resource exhaustion (CPU, memory, disk)              │   │
│  │ • Network issues                                       │   │
│  │ • Query plan changes                                   │   │
│  │ • Data volume growth                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Apply Fixes                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Scale resources                                      │   │
│  │ • Optimize queries                                     │   │
│  │ • Add caching                                          │   │
│  │ • Partition data                                       │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q20: How do you troubleshoot infrastructure as code issues?

Answer:

IaC Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Infrastructure as Code Troubleshooting             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  CloudFormation                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Check stack events                                   │   │
│  │ • Review error messages                                │   │
│  │ • Check IAM permissions                                │   │
│  │ • Verify resource limits                               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  CDK                                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Synthesize and review templates                      │   │
│  │ • Check for circular dependencies                     │   │
│  │ • Verify context values                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Terraform                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Run terraform plan first                            │   │
│  │ • Check state file                                     │   │
│  │ • Verify provider configuration                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q21: How do you troubleshoot monitoring gaps?

Answer:

Monitoring Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Monitoring Gap Troubleshooting                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Identify Gaps                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Missing metrics                                      │   │
│  │ • No alerts for critical failures                      │   │
│  │ • Incomplete dashboards                                │   │
│  │ • No logging for key operations                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Implement Missing Monitoring                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Custom CloudWatch metrics                            │   │
│  │ • CloudTrail for API logging                           │   │
│  │ • X-Ray for tracing                                    │   │
│  │ • CloudWatch Logs Insights                             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Validate Coverage                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • SLI/SOLO coverage                                    │   │
│  │ • Alert response time                                  │   │
│  │ • Dashboard completeness                               │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q22: How do you troubleshoot compliance issues?

Answer:

Compliance Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Compliance Troubleshooting                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step 1: Identify Non-Compliance                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • AWS Config rules                                     │   │
│  │ • Security Hub findings                                │   │
│  │ • Audit Manager assessments                            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 2: Assess Impact                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Which resources are affected?                        │   │
│  │ • What data is at risk?                                │   │
│  │ • Regulatory implications                              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Step 3: Remediate                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Enable encryption                                    │   │
│  │ • Update access controls                               │   │
│  │ • Enable logging                                       │   │
│  │ • Update policies                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q23: How do you troubleshoot multi-region issues?

Answer:

Multi-Region Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Multi-Region Troubleshooting                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Common Issues                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Replication lag                                      │   │
│  │ • Region-specific service issues                      │   │
│  │ • Cross-region latency                                 │   │
│  │ • Data consistency across regions                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Troubleshooting Steps                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ 1. Check replication status per region                 │   │
│  │ 2. Verify cross-region connectivity                    │   │
│  │ 3. Check region-specific quotas                        │   │
│  │ 4. Review region-specific costs                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q24: How do you troubleshoot batch job scheduling issues?

Answer:

Scheduling Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Batch Job Scheduling Troubleshooting               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Common Issues                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Job not running                                      │   │
│  │ • Job running late                                     │   │
│  │ • Job failing intermittently                           │   │
│  │ • Dependency issues                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Troubleshooting Steps                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ 1. Check scheduler (Airflow, Step Functions)           │   │
│  │ 2. Verify IAM permissions                              │   │
│  │ 3. Check resource availability                         │   │
│  │ 4. Review dependency chain                             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Solutions                                                      │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Add retry logic                                      │   │
│  │ • Implement dead letter queues                         │   │
│  │ • Add monitoring and alerting                          │   │
│  │ • Implement circuit breakers                           │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q25: How do you troubleshoot disaster recovery scenarios?

Answer:

DR Troubleshooting:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Disaster Recovery Troubleshooting                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Pre-DR Checklist                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Backup status and freshness                          │   │
│  │ • Replication lag                                      │   │
│  │ • DR site readiness                                    │   │
│  │ • DNS failover configuration                           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  During DR                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Activate DR site                                     │   │
│  │ • Update DNS                                           │   │
│  │ • Restore from backups                                 │   │
│  │ • Verify data integrity                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Post-DR                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Validate all services are running                    │   │
│  │ • Check data consistency                               │   │
│  │ • Monitor for issues                                   │   │
│  │ • Plan failback                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Summary

Mastering AWS troubleshooting requires understanding:

Methodology: Systematic approach to identify, diagnose, resolve
Service-Specific Issues: Athena, EMR, Redshift, Glue, Lambda, S3
Common Patterns: Performance, connectivity, security, cost
Prevention: Monitoring, alerting, automation, documentation
Tools: CloudWatch, CloudTrail, X-Ray, Config

These concepts form the foundation for effectively debugging and resolving issues in AWS data systems.

AWS Troubleshooting Interview Questions

🔧 AWS Troubleshooting Interview

Troubleshooting Framework

Q1: How do you troubleshoot slow Athena queries?

Q2: How do you troubleshoot EMR cluster failures?

Q3: How do you troubleshoot Redshift query performance?

Q4: How do you troubleshoot Glue job failures?

Q5: How do you troubleshoot Lambda function failures?

Q6: How do you troubleshoot S3 performance issues?

Q7: How do you troubleshoot network connectivity issues?

Q8: How do you troubleshoot IAM permission issues?

Q9: How do you troubleshoot data quality issues?

Q10: How do you troubleshoot Spark job failures?

Q11: How do you troubleshoot Kinesis stream issues?

Q12: How do you troubleshoot Glue Data Catalog issues?

Q13: How do you troubleshoot cost anomalies?

Q14: How do you troubleshoot data replication issues?

Q15: How do you troubleshoot serverless application issues?

Q16: How do you troubleshoot security vulnerabilities?

Q17: How do you troubleshoot slow ETL pipelines?

Q18: How do you troubleshoot data consistency issues?

Q19: How do you troubleshoot performance degradation?

Q20: How do you troubleshoot infrastructure as code issues?

Q21: How do you troubleshoot monitoring gaps?

Q22: How do you troubleshoot compliance issues?

Q23: How do you troubleshoot multi-region issues?

Q24: How do you troubleshoot batch job scheduling issues?

Q25: How do you troubleshoot disaster recovery scenarios?

Summary