Best Practice: Energieeffiziente Compute-Auswahl (ARM/Graviton, Spot)

# AWS: Alle EC2-Instanztypen inventarisieren und nach Familie gruppieren
aws ec2 describe-instances \
  --query "Reservations[].Instances[].[InstanceId,InstanceType,Tags[?Key=='environment'].Value|[0],State.Name]" \
  --output json | jq '
  group_by(.[1] | split(".")[0]) |
  map({
    family: .[0][1] | split(".")[0],
    count: length,
    instances: map(.[0])
  })
  | sort_by(.family)'

# Filtern: Previous-Gen Familien identifizieren
aws ec2 describe-instances \
  --filters "Name=instance-state-name,Values=running" \
  --query "Reservations[].Instances[].[InstanceId,InstanceType]" \
  --output json | jq '.[] | select(.[1] | test("^(t2|m4|c4|r4|i2|d2|m3|c3)\\."))'

# Bestehende Lambda-Funktion auf arm64 migrieren
resource "aws_lambda_function" "api_handler" {
  function_name = "api-handler"
  runtime       = "python3.12"

  # MIGRATION: x86_64 -> arm64
  architectures = ["arm64"]  # War: ["x86_64"]

  handler  = "main.handler"
  role     = aws_iam_role.lambda_exec.arn
  filename = "function.zip"

  # Keine weiteren Änderungen erforderlich für Python/Node.js/Java
  environment {
    variables = {
      ENVIRONMENT = var.environment
    }
  }

  tags = {
    workload                = "api-service"
    environment             = var.environment
    owner                   = "platform-team"
    sustainability-reviewed = "2026-01-15"
  }
}

# Lambda Layer: Prüfen ob arm64-kompatibel
resource "aws_lambda_layer_version" "utils" {
  layer_name  = "utils-layer"
  filename    = "utils-layer.zip"

  # Explizit arm64 kompatible Architektur angeben
  compatible_architectures = ["arm64"]
  compatible_runtimes      = ["python3.12", "python3.11"]
}

# Greenfield: Graviton3 als Default
resource "aws_launch_template" "app_lt" {
  name_prefix   = "app-"
  image_id      = data.aws_ami.ubuntu_arm64.id
  instance_type = "m7g.large"  # Graviton3

  # Graviton erfordert arm64-kompatibles AMI
  # Ubuntu 22.04 LTS ARM64: ami-0xxxx (region-spezifisch)

  tags = {
    workload    = "app-service"
    environment = var.environment
  }
}

# AMI-Data-Source für ARM64
data "aws_ami" "ubuntu_arm64" {
  most_recent = true
  owners      = ["099720109477"]  # Canonical

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-arm64-server-*"]
  }

  filter {
    name   = "architecture"
    values = ["arm64"]
  }
}

# Graviton-Instanztyp-Mapping (x86 → Graviton Äquivalent):
locals {
  graviton_mapping = {
    "t2.micro"   = "t4g.micro"
    "t2.small"   = "t4g.small"
    "t2.medium"  = "t4g.medium"
    "t3.medium"  = "t4g.medium"
    "m4.large"   = "m7g.large"
    "m5.large"   = "m7g.large"
    "m6i.large"  = "m7g.large"
    "c4.large"   = "c7g.large"
    "c5.large"   = "c7g.large"
    "r4.large"   = "r7g.large"
    "r5.large"   = "r7g.large"
  }
}

# .github/workflows/sustainability-check.yml
name: Sustainability Compliance Check

on:
  pull_request:
    paths:
      - 'infrastructure/**/*.tf'

jobs:
  compute-efficiency-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: WAF++ Compute Efficiency Check
        run: |
          # Prüfe auf Previous-Generation Instanztypen
          VIOLATIONS=$(grep -rn 'instance_type\s*=\s*"' infrastructure/ | \
            grep -E '"(t2|m4|c4|r4|i2|d2|m3|c3)\.' || true)

          if [ -n "$VIOLATIONS" ]; then
            echo "WAF-SUS-020 Violation: Previous-generation instance types found:"
            echo "$VIOLATIONS"
            echo "Please use Graviton (m7g, c7g, r7g, t4g) or current-gen x86 (m6i, c6i)"
            exit 1
          fi

          # Prüfe Lambda auf arm64
          LAMBDA_X86=$(grep -rn 'architectures\s*=\s*\["x86_64"\]' infrastructure/ || true)
          if [ -n "$LAMBDA_X86" ]; then
            echo "WAF-SUS-020 Warning: Lambda functions using x86_64 architecture:"
            echo "$LAMBDA_X86"
            echo "Please use architectures = [\"arm64\"] for 20% energy reduction"
          fi

          echo "Compute efficiency check passed!"

      - name: Summarize compute architecture
        if: always()
        run: |
          echo "=== Compute Architecture Summary ==="
          echo "ARM64/Graviton instances:"
          grep -rn 'instance_type' infrastructure/ | \
            grep -E '"(t4g|m7g|c7g|r7g|m6g|c6g|r6g|a1)\.' || echo "None found"
          echo ""
          echo "x86 instances:"
          grep -rn 'instance_type' infrastructure/ | \
            grep -E '"(t3|t4|m5|m6i|c5|c6i|r5|r6i)\.' || echo "None found"

# Autoscaling Group mit Spot-Integration für Dev-Umgebung
resource "aws_autoscaling_group" "dev_workers" {
  name                = "dev-workers-asg"
  vpc_zone_identifier = var.private_subnets
  min_size            = 0  # Scale to Zero
  max_size            = 10
  desired_capacity    = 0

  mixed_instances_policy {
    instances_distribution {
      on_demand_base_capacity                  = 0
      on_demand_percentage_above_base_capacity = 0   # 100% Spot für Dev
      spot_allocation_strategy                 = "capacity-optimized"
    }

    launch_template {
      launch_template_specification {
        launch_template_id      = aws_launch_template.dev_worker.id
        version                 = "$Latest"
      }

      # Mehrere Graviton-Typen für Spot-Resilienz
      override {
        instance_type = "t4g.medium"
      }
      override {
        instance_type = "t4g.large"
      }
      override {
        instance_type = "m7g.medium"
      }
      override {
        instance_type = "c7g.medium"
      }
    }
  }

  tag {
    key                 = "environment"
    value               = "development"
    propagate_at_launch = true
  }

  tag {
    key                 = "sustainability-reviewed"
    value               = "2026-01-15"
    propagate_at_launch = true
  }
}