Cloud Migration Assessment and Planning Explained -- Complete Guide

# AWS Migration Evaluator (formerly TSO Logic) CLI
# Generate discovery report
aws migration-hub create-progress-update-stream \
  --progress-update-stream-name dodatech-migration-stream

# Start data collection from on-premises servers
aws discovery start-data-collection \
  --agent-ids "agent-1234567890abcdef0"

# List discovered servers
aws discovery describe-agents \
  --filters '[{"name": "agentNetworkInfoList.ipAddress", "values": ["10.0.0.0/8"], "condition": "CONTAINS"}]'

# Get migration recommendations
aws migration-hub notify-migration-task-state \
  --task-id "mig-1234567890abcdef0" \
  --migration-task status=RECOMMENDED \
  --progress-update-stream dodatech-migration-stream

# landing-zone.tf
# Terraform: Multi-account AWS landing zone for migration
# Security account for centralized logging and audit
resource "aws_organizations_account" "security" {
  name  = "dodatech-security"
  email = "aws-security@dodatech.com"

  tags = {
    Environment = "security"
    ManagedBy   = "terraform"
  }
}

# Shared services account for networking, directory, CI/CD
resource "aws_organizations_account" "shared" {
  name  = "dodatech-shared"
  email = "aws-shared@dodatech.com"

  tags = {
    Environment = "shared"
    ManagedBy   = "terraform"
  }
}

# Migration account for temporary workloads during transition
resource "aws_organizations_account" "migration" {
  name  = "dodatech-migration"
  email = "aws-migration@dodatech.com"

  tags = {
    Environment = "migration"
    ManagedBy   = "terraform"
  }
}

# Service Control Policy to enforce encryption
resource "aws_organizations_policy" "encryption_scp" {
  name = "dodatech-encryption-scp"
  description = "Require encryption for all storage services"

  content = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Deny]
        Action = [
          "s3:CreateBucket",
          "ec2:CreateVolume",
          "rds:CreateDBInstance",
        ]
        Resource = "*"
        Condition = {
          Bool = {
            "aws:SecureTransport": "false"
          }
        }
      },
    ]
  })
}

# AWS TCO Calculator with AWS CLI
# Calculate total cost of ownership for migration
aws ce get-cost-forecast \
  --time-period Start=2026-06-01,End=2027-06-01 \
  --metric "BLENDED_COST" \
  --granularity "MONTHLY" \
  --filter '{"Dimensions": {"Key": "SERVICE", "Values": ["AmazonEC2"]}}'

# Compare on-prem vs cloud TCO
cat > tco_comparison.json << 'EOF'
{
  "onPremises": {
    "servers": 200,
    "storage": 500000,
    "network": 10000,
    "power_cooling": 5000,
    "staff": 300000,
  },
  "cloud": {
    "compute": 150000,
    "storage": 15000,
    "data_transfer": 2000,
    "support": 20000,
    "migration_cost": 100000,
  }
}
EOF

# Example migration wave plan
cat > migration_waves.json << 'EOF'
{
  "wave1": {
    "name": "Quick Wins",
    "applications": ["Dev Tools", "Internal Wiki", "CI/CD"],
    "strategy": "Rehost",
    "timeline": "Month 1-2",
    "risk": "Low"
  },
  "wave2": {
    "name": "Core Infrastructure",
    "applications": ["Active Directory", "DNS", "Monitoring"],
    "strategy": "Replatform",
    "timeline": "Month 2-4",
    "risk": "Medium"
  },
  "wave3": {
    "name": "Business Applications",
    "applications": ["CRM", "ERP", "HR System"],
    "strategy": "Rehost or Replatform",
    "timeline": "Month 4-8",
    "risk": "High"
  },
  "wave4": {
    "name": "Cloud-Native Transformation",
    "applications": ["Customer Portal", "Data Platform"],
    "<a href="/design-patterns/strategy/">Strategy</a>": "Refactor",
    "timeline": "Month 8-12",
    "risk": "High"
  }
}
EOF

# migration_planner.py
# Plan migration waves with dependencies and timelines
from typing import List, Dict
from datetime import datetime, timedelta

class AppMigration:
    def __init__(self, name: str, strategy: str, dependencies: List[str],
                 complexity: str, data_gb: int):
        self.name = name
        self.strategy = strategy
        self.dependencies = dependencies
        self.complexity = complexity
        self.data_gb = data_gb

    def estimated_days(self) -> int:
        base = {"Rehost": 5, "Replatform": 15, "Refactor": 40, "Repurchase": 20}
        complexity_mult = {"Low": 1, "Medium": 2, "High": 3}
        return base[self.strategy] * complexity_mult[self.complexity]

def plan_waves(apps: List[AppMigration]) -> List[Dict]:
    unplanned = {a.name: a for a in apps}
    waves = []
    wave_num = 1
    start_date = datetime.now()

    while unplanned:
        # Find apps with all dependencies met
        wave_apps = []
        for name, app in list(unplanned.items()):
            deps_met = all(dep not in unplanned for dep in app.dependencies)
            if deps_met or not app.dependencies:
                wave_apps.append(app)
                del unplanned[name]

        if not wave_apps:
            break  # circular dependency

        wave_end = start_date + timedelta(days=max(a.estimated_days() for a in wave_apps))
        waves.append({
            "wave": wave_num,
            "apps": [a.name for a in wave_apps],
            "start": start_date.strftime("%Y-%m-%d"),
            "end": wave_end.strftime("%Y-%m-%d"),
            "duration_days": max(a.estimated_days() for a in wave_apps),
            "total_data_gb": sum(a.data_gb for a in wave_apps),
        })
        start_date = wave_end
        wave_num += 1

    return waves

print("=== Migration Wave Plan ===\n")
apps = [
    AppMigration("DevTools", "Rehost", [], "Low", 10),
    AppMigration("Internal Wiki", "Rehost", ["ActiveDirectory"], "Low", 50),
    AppMigration("ActiveDirectory", "Replatform", [], "Medium", 5),
    AppMigration("CRM", "Replatform", ["ActiveDirectory", "Database"], "High", 100),
    AppMigration("Database", "Replatform", [], "Medium", 500),
    AppMigration("Customer Portal", "Refactor", ["Database", "CRM"], "High", 200),
]

waves = plan_waves(apps)
print(f"{'Wave':<8} {'Apps':<35} {'Duration':<12} {'Data':<12} {'Period'}")
print("=" * 75)
for w in waves:
    apps_str = ", ".join(w["apps"])
    print(f"Wave {w['wave']:<3} {apps_str:<35} {w['duration_days']:<12}d {w['total_data_gb']:<12}GB {w['start']} - {w['end']}")

total_duration = (datetime.strptime(waves[-1]['end'], "%Y-%m-%d") - datetime.strptime(waves[0]['start'], "%Y-%m-%d")).days
print(f"\nTotal migration timeline: {total_duration} days")
print(f"Total applications: {len(apps)}")
print(f"Total data to migrate: {sum(w['total_data_gb'] for w in waves)} GB")