Skip to Content
Cloud Engineering Academy
13. Microsoft-to-AWS Migration

Azure vs AWS: the big picture

Map the Azure structures you know (tenant, subscription, resource group, region pair, VNet, NSG, managed identity) onto their AWS counterparts, and learn the handful of differences that cause real outages and surprise bills during a migration.

intermediate⏱ 1 h 15 min🟢 FreeCLF-C02SAA-C03SAP-C03

Assumes: .NET 10 LTS (file-based apps) · AWS SDK for .NET v4 · AWS CLI v2 · Azure CLI (read-only inventory) · Region us-east-1. Verified against official sources on 2026-11-18.

Learning objectives

By the end of this lesson you can:

  • Translate the Azure management hierarchy (tenant, management group, subscription, resource group) into the AWS one (organisation, organisational unit, account) and say what has no equivalent.
  • Explain why an AWS account is a hard security and billing boundary, and why that changes how you split environments.
  • Compare Azure and AWS networking building blocks and name the three differences that break lifted-and-shifted designs.
  • Explain the difference between an Azure managed identity and an AWS IAM role, and why DefaultAzureCredential has an AWS counterpart you already use.
  • Run a small C# tool that converts an Azure resource-type inventory into a first-draft AWS shopping list.

Prerequisites

Why this matters in banking

Harbourline Bank's platform team spent two years on Azure. A proposal lands: "we will recreate the Azure landing zone on AWS, one for one." Three months in, the audit team asks which AWS accounts hold production payment data, and nobody can answer, because the team created one account called prod and treated it like an Azure subscription full of resource groups. A single leaked IAM policy now exposes every workload in that account. The workloads cannot be separated later without re-creating them.

Migrations rarely fail on the big technical choices. They fail on assumptions carried across silently: "a resource group is a unit of deletion", "the VNet spans the region", "the managed identity is automatic". This lesson lists those assumptions so you can check each one on purpose. It sets the vocabulary for the rest of the module, and for the regulator-facing question every change board asks: what is the new blast radius?

The idea in plain language

Both clouds sell the same raw things: compute, storage, networks, databases and identity. They organise them differently.

  • Azure is organised around identity first. One Microsoft Entra tenant (your company's directory) sits at the top. Beneath it, management groups hold subscriptions (the billing and quota container), and inside a subscription you group resources into resource groups. Role assignments flow down that tree.
  • AWS is organised around the account first. An AWS account is a container for resources, a billing entity and a security boundary. AWS Organizations groups accounts into organisational units (OUs). There is no resource group layer and no automatic downward inheritance of permissions. Guardrails flow down as service control policies (SCPs), which only ever limit; they never grant.

Analogy: Azure is an office building with one reception desk (the tenant) and floors (subscriptions) divided into rooms (resource groups); your pass is checked at the desk and works on every floor you are cleared for. AWS is a business park of separate buildings (accounts), each with its own locks and its own bill. A park-wide rulebook (SCPs) says what no building may ever do, but each building's own keys decide who goes in.

What problem this comparison solves

You will meet three kinds of difference, and it helps to sort them as you go:

KindExampleWhat to do
RenamedAzure Blob Storage is S3; Key Vault secrets are in Secrets ManagerUse the mapping table; behaviour is close
ReshapedA resource group has no AWS twin; an NSG becomes a security group plus an optional NACLRedesign the structure, not just the names
Different guaranteesAWS Regions do not pair; account boundaries are hard; IAM evaluates explicit deny firstRe-check every assumption in the design and the risk register

Honest limits: this lesson is a map, not a replacement for the deep dives. Where a topic has its own lesson, the section links to it.

Microsoft / Azure comparison

Organisation, billing and governance

You know (Azure)AWS equivalentWhat's different
Entra ID tenantAWS Organizations (structure) plus IAM Identity Center (people)Identity and structure are separate services. The tenant is both in Azure
Management groupOrganisational unit (OU)OUs nest up to five levels deep ⚠ VERIFY the current limit; SCPs attach to OUs
SubscriptionAWS accountThe account is the strongest boundary AWS offers: separate IAM, quotas, bill and blast radius
Resource groupNo equivalent. Use tags, CloudFormation stacks or AWS Resource GroupsDeleting "everything for an app" means deleting a stack, not a group
Azure PolicySCPs (limit), AWS Config rules (detect), Control Tower controlsSCPs say what is impossible; Config says what is non-compliant
Azure RBAC role assignmentIAM policy attached to a user, role or group, or an Identity Center permission setPolicies are JSON documents with explicit Deny; there is no downward inheritance
Cost Management + BillingCost Explorer, Budgets, Cost and Usage ReportConsolidated billing across an organisation; tags must be activated as cost allocation tags
Azure support plansAWS Support plansAWS announced new paid plans in December 2025 (Business Support+, Enterprise Support, Unified Operations); older Developer, Business and Enterprise On-Ramp plans remain only until 2027-01-01. See the AWS announcement and check prices on the official page before budgeting

Regions, zones and resilience

You know (Azure)AWS equivalentWhat's different
Region pair (for example UK South and UK West)No pairing. You choose a DR Region yourselfYou decide replication targets, and you check data-residency rules for the one you pick
Availability Zone (zone-redundant services)Availability ZoneMany AWS services are not zone-redundant by default; you opt in (Multi-AZ RDS, an Auto Scaling group across subnets)
Zone mapping is per subscriptionAZ names (us-east-1a) are mapped per accountUse the AZ ID (use1-az1) when two accounts must agree on a physical zone
Geo-redundant storage (GRS)S3 Cross-Region Replication, or Multi-Region features per serviceReplication is a configured feature, not a storage tier choice
Global services in a tenantIAM, Route 53, CloudFront are global; almost everything else is regionalResources never "float"; check the Region selector before every action

Networking

You know (Azure)AWS equivalentWhat's different
VNet (regional)VPC (regional)Same scope, but subnets are tied to one AZ in AWS; in Azure a subnet normally spans the zones
Network security group (NSG), statefulSecurity group (stateful, allow-only) and optionally a network ACL (stateless, allow and deny, per subnet)Security groups attach to network interfaces and can reference other security groups as sources
User-defined route (UDR)Route tableAssociated per subnet; the local route is implicit
VNet peeringVPC peering or Transit GatewayPeering is not transitive; Transit Gateway is the hub-and-spoke tool
Private Endpoint / Private LinkVPC endpoints (interface and gateway) and PrivateLinkS3 and DynamoDB also offer free gateway endpoints
Azure FirewallAWS Network Firewall (and security groups)See Network Firewall
Application Gateway (L7), Load Balancer (L4)Application Load Balancer, Network Load BalancerA load balancer is a regional resource spanning the subnets you give it
Front Door / CDNCloudFront (plus Global Accelerator)CloudFront is the edge front door; WAF attaches to it
ExpressRoute / VPN GatewayDirect Connect / Site-to-Site VPNCovered later in this module's hybrid networking lesson; see Network migration and hybrid architecture

Identity for workloads

You know (Azure)AWS equivalentWhat's different
System-assigned managed identityIAM role attached to EC2 (instance profile), an ECS task (task role) or a Lambda function (execution role)You create and name the role; there is no "turn on identity" switch, but there is also no secret to store
DefaultAzureCredentialThe default credential provider chain in the AWS SDK (environment, profile, SSO, container role, instance role)Same idea: code stays identical from laptop to cloud
Service principal with a client secretAn IAM role assumed with OIDC federation; avoid IAM users with access keysSee IAM Identity Center, MFA and STS

Architecture

The shape of an enterprise estate on each side:

Security-boundary view. In Azure the blast radius of a mistaken Owner assignment is the scope you assigned it at, often a whole subscription. In AWS the account is a wall: an admin in payments-prod has no rights in accounts-prod unless a role trust and the other side's policy both allow it. This is why a typical bank landing zone has tens or hundreds of accounts, not four.

Step-by-step implementation

Inventory what you actually run on Azure

You cannot map what you have not listed. Export resource types from every subscription (read-only):

# For each subscription you have Reader on. Reader cannot change anything.
az account list --query "[].id" -o tsv | while read sub; do
  az resource list --subscription "$sub" --query "[].type" -o tsv
done | sort | uniq -c | sort -rn > azure-types.txt

No Azure access? Use the sample file in the exercises.

Turn the inventory into a draft AWS list

Use the C# tool in the Complete code section. It reads azure-types.txt, looks each type up in a mapping table, and prints the AWS service, the kind of difference (renamed, reshaped, different guarantees) and the lesson to read next. Unknown types are listed separately, because the unknowns are where the risk is.

Decide the account structure before the first workload

Sketch OUs and accounts on paper: one account per workload per environment (for example payments-prod, payments-test), plus shared accounts for logging, security tooling and networking. The landing-zone pattern is covered in Accounts and AWS Organizations and Multi-account networking.

Check identity and the Region rule

Decide which AWS Regions are allowed (an SCP can deny all others) and how staff will sign in. The usual answer for an Azure estate is: keep Entra ID as the identity source and federate it into IAM Identity Center. The monitoring and identity lesson shows the patterns.

AWS Console instructions

Nothing in this lesson needs the console to create resources. To see the structure for yourself in a sandbox: Console → AWS Organizations → AWS accounts shows the tree; Console → EC2 → Settings → Zones (or EC2 → Dashboard → Account attributes) shows your AZ names and their IDs. Look for the AZ ID column, the one that stays stable across accounts.

AWS CLI

# Who am I, and in which account? Run this before anything else, every time.
aws sts get-caller-identity --profile learn-sandbox

# Name versus ID of each Availability Zone in this account. The ID is the stable one.
aws ec2 describe-availability-zones --profile learn-sandbox --region us-east-1 \
  --query "AvailabilityZones[].[ZoneName,ZoneId]" --output table

# The organisation tree (only works in the management account or a delegated admin).
aws organizations list-roots --profile learn-sandbox
aws organizations list-accounts --profile learn-sandbox --query "Accounts[].[Name,Status]" --output table

If list-accounts returns AWSOrganizationsNotInUseException or AccessDenied, your sandbox is a standalone account. That is fine for learning.

Infrastructure as Code

The structure itself is code. The example is design-only: do not apply it in your sandbox, because creating OUs needs the Organizations management account.

OuStack.cs
using Amazon.CDK;
using Amazon.CDK.AWS.Organizations;
using Constructs;

public sealed class OuStack : Stack
{
    public OuStack(Construct scope, string id, string rootId) : base(scope, id)
    {
        // Parent ID is the organisation root (r-xxxx). OUs are cheap; accounts are the real boundary.
        var workloads = new CfnOrganizationalUnit(this, "Workloads", new CfnOrganizationalUnitProps
        {
            Name = "Workloads",
            ParentId = rootId,
        });

        _ = new CfnOrganizationalUnit(this, "WorkloadsProd", new CfnOrganizationalUnitProps
        {
            Name = "Workloads-Prod",
            ParentId = workloads.Ref,
        });

        Amazon.CDK.Tags.Of(this).Add("Project", "cea-lab");
    }
}

Complete code

A single-file C# program (no project needed with the .NET 10 SDK). Save it as map-azure.cs and run dotnet run map-azure.cs azure-types.txt.

map-azure.cs
// Maps Azure resource types (from `az resource list`) to AWS services and the lesson to read next.
// Input lines look like:  12 Microsoft.Web/sites   (a count, then the type) or just the type.

var path = args.Length > 0 ? args[0] : "azure-types.txt";
if (!File.Exists(path))
{
    Console.Error.WriteLine($"File not found: {path}");
    return 1;
}

var map = new Dictionary<string, (string Aws, string Kind, string Next)>(StringComparer.OrdinalIgnoreCase)
{
    ["Microsoft.Web/sites"] = ("Elastic Beanstalk, ECS Express Mode or ECS on Fargate", "Reshaped", "hosting-side-by-side"),
    ["Microsoft.Web/serverfarms"] = ("No equivalent (capacity is part of the hosting service)", "Reshaped", "hosting-side-by-side"),
    ["Microsoft.Compute/virtualMachines"] = ("Amazon EC2 (Windows or Linux)", "Renamed", "hosting-side-by-side"),
    ["Microsoft.ContainerService/managedClusters"] = ("Amazon EKS", "Renamed", "hosting-side-by-side"),
    ["Microsoft.App/containerApps"] = ("ECS Express Mode or ECS on Fargate", "Reshaped", "hosting-side-by-side"),
    ["Microsoft.Sql/servers/databases"] = ("RDS for SQL Server or Aurora PostgreSQL with Babelfish", "Reshaped", "data-services-side-by-side"),
    ["Microsoft.DocumentDB/databaseAccounts"] = ("Amazon DynamoDB (or DocumentDB)", "Reshaped", "data-services-side-by-side"),
    ["Microsoft.Storage/storageAccounts"] = ("Amazon S3 (blobs), EFS or FSx (files)", "Reshaped", "data-services-side-by-side"),
    ["Microsoft.Cache/Redis"] = ("ElastiCache for Valkey or Redis OSS", "Renamed", "data-services-side-by-side"),
    ["Microsoft.ServiceBus/namespaces"] = ("SQS, SNS and EventBridge", "Reshaped", "integration-side-by-side"),
    ["Microsoft.EventGrid/topics"] = ("Amazon EventBridge", "Renamed", "integration-side-by-side"),
    ["Microsoft.ApiManagement/service"] = ("Amazon API Gateway", "Reshaped", "integration-side-by-side"),
    ["Microsoft.KeyVault/vaults"] = ("Secrets Manager plus AWS KMS", "Reshaped", "devops-iac-secrets-side-by-side"),
    ["Microsoft.Insights/components"] = ("CloudWatch, X-Ray and OpenTelemetry", "Reshaped", "monitoring-identity-side-by-side"),
    ["Microsoft.OperationalInsights/workspaces"] = ("CloudWatch Logs (Logs Insights)", "Reshaped", "monitoring-identity-side-by-side"),
    ["Microsoft.ManagedIdentity/userAssignedIdentities"] = ("IAM roles", "Reshaped", "monitoring-identity-side-by-side"),
    ["Microsoft.Network/virtualNetworks"] = ("Amazon VPC", "Reshaped", "azure-vs-aws-big-picture"),
    ["Microsoft.Network/networkSecurityGroups"] = ("Security groups and network ACLs", "Reshaped", "azure-vs-aws-big-picture"),
    ["Microsoft.Network/applicationGateways"] = ("Application Load Balancer (plus WAF)", "Renamed", "azure-vs-aws-big-picture"),
    ["Microsoft.Network/loadBalancers"] = ("Network Load Balancer", "Renamed", "azure-vs-aws-big-picture"),
    ["Microsoft.Network/privateEndpoints"] = ("VPC interface endpoints (PrivateLink)", "Renamed", "azure-vs-aws-big-picture"),
    ["Microsoft.Resources/resourceGroups"] = ("Tags and CloudFormation stacks", "Different guarantees", "azure-vs-aws-big-picture"),
};

var known = new List<string>();
var unknown = new List<string>();

foreach (var line in File.ReadLines(path).Where(l => !string.IsNullOrWhiteSpace(l)))
{
    var parts = line.Trim().Split(' ', 2, StringSplitOptions.RemoveEmptyEntries);
    var count = parts.Length == 2 && int.TryParse(parts[0], out var n) ? n : 1;
    var type = parts.Length == 2 && int.TryParse(parts[0], out _) ? parts[1].Trim() : parts[0];

    if (map.TryGetValue(type, out var m))
    {
        known.Add($"{count,4} x {type,-50} -> {m.Aws} [{m.Kind}] (read: {m.Next})");
    }
    else
    {
        unknown.Add($"{count,4} x {type}");
    }
}

Console.WriteLine("Mapped:");
known.ForEach(Console.WriteLine);
Console.WriteLine();
Console.WriteLine($"Unmapped ({unknown.Count}). These need a human:");
unknown.ForEach(Console.WriteLine);
return 0;

Code explained line by line

  1. The top comment states the input shape. az resource list --query "[].type" plus uniq -c yields count type lines, so the parser accepts both a count and a bare type.
  2. args.Length > 0 ? args[0] : ... takes the file path from the command line with a default, so dotnet run map-azure.cs works with no arguments.
  3. The Dictionary is case-insensitive because Azure resource types are not consistent about case across tools.
  4. Each entry is a tuple of the AWS landing spot, the kind of difference (the three-way sort from earlier) and the next lesson slug. The mapping is deliberately opinionated and short: it is a first draft, not an oracle.
  5. Split(' ', 2, ...) splits only on the first space so type names with spaces would survive; int.TryParse decides whether the first token is a count.
  6. Anything not in the dictionary goes to the unknown list and is printed last. The unknown list is the work plan: a type nobody mapped is a type nobody has thought about.

Security considerations

⚠ Learning shortcut — not for production

The inventory step uses your own Azure Reader access on your laptop. In a real programme, inventory runs from a dedicated, read-only identity in each subscription, its output is stored in a controlled location (it reveals your whole architecture), and the migration team gets only the subscriptions in scope. Treat the resource inventory as confidential: it is an attacker's map.

  • Do not copy Azure RBAC into AWS one for one. Azure Owner at subscription level is a wide grant. Rebuild access as Identity Center permission sets per account and role, with MFA and short sessions.
  • Plan the SCP guardrails on day one: deny unused Regions, deny leaving the organisation, deny disabling CloudTrail. These are the AWS equivalent of Azure Policy deny effects.
  • Data residency: UK GDPR and EU GDPR treat the choice of Region as a legal matter. Pick Regions with your DPO. This lesson does not make a legal determination.
  • Shared responsibility moves in both directions. Moving from PaaS to EC2 hands OS patching back to you. See the shared responsibility model.

Banking use case

Harbourline's Azure estate has a payments subscription with eight resource groups. The AWS design splits it on data classification and change cadence, not on the Azure layout:

  • payments-prod and payments-nonprod accounts, so a test pipeline cannot touch production keys.
  • A separate payments-data-prod account for the ledger database, with only the payments-prod roles allowed to connect.
  • Shared log-archive and security-tooling accounts that application teams cannot write to, giving the audit team an independent evidence trail.

The Azure resource groups become CloudFormation stacks and tag sets inside those accounts. Nothing is lost; the unit of deletion is just a different object.

Common mistakes

  • One big account. Why: it feels like one subscription. Result: a shared blast radius and an impossible split later. Avoid it by planning accounts per workload and environment.
  • Assuming zone redundancy. Why: many Azure PaaS services are zone-redundant by setting. In AWS, a single-AZ RDS instance or a one-subnet Auto Scaling group is single-AZ. Check each service.
  • Using AZ names across accounts. us-east-1a in your account may not be the same physical zone as in another. Use AZ IDs for shared designs.
  • Recreating a "default VNet". Teams copy an Azure address plan and discover overlaps with on-premises ranges. Fix the CIDR plan first (CIDR planning).
  • Expecting permissions to inherit. An administrator at the organisation level has no access inside member accounts by default.

Troubleshooting

SymptomLikely causeFix
AccessDenied on organizations list-accountsYou are in a member account, not the management accountExpected. Use a delegated administrator or skip the command
Resource "missing" after an actionWrong Region selected in the console or CLICheck --region or the console Region selector, then re-run
Two accounts disagree about "the same zone"AZ names are mapped per accountCompare AZ IDs with describe-availability-zones
A peered VPC cannot reach a third VPCPeering is not transitiveUse a Transit Gateway or add a direct peering
Tool prints many unmapped typesInventory contains child resource types (extensions, rules)Filter to top-level types, then review the rest by hand

Cost and cleanup

This lesson costs nothing: describe-availability-zones, sts get-caller-identity and organizations reads are free, and the C# tool runs locally. The IaC samples are design-only and are not applied. There is nothing to tear down; confirm with:

# Anything tagged for this course should be empty for this lesson.
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab \
  --profile learn-sandbox --region us-east-1 --query "ResourceTagMappingList[].ResourceARN"

Exercises

  • 🟢 Guided: create azure-types.txt with the sample lines in the solution, run the tool, and list three types it maps as Reshaped.
  • 🟡 Challenge: extend the mapping table with five more Azure types you use at work (for example Microsoft.Logic/workflows, Microsoft.DataFactory/factories) and decide the kind of difference for each. Mark any AWS equivalent you cannot verify with ⚠ VERIFY.
  • 🔴 Live problem: your CTO says "keep the same resource groups and subscriptions so the Azure team feels at home." Write a one-page reply that explains the account-as-boundary difference, proposes an account structure for three Harbourline workloads, and names two controls the auditor will ask for.

Assignment

Produce a structure comparison page for your own organisation: a diagram of the current Azure hierarchy, a proposed AWS organisation (OUs, accounts, SCPs, identity source), and a table of the five assumptions you will test first. Commit it to your portfolio repository.

Solutions

Knowledge check

Interview questions

  • "We have 60 Azure subscriptions. How many AWS accounts would you create?" Not a number: one account per workload per environment, plus shared accounts for logs, security tooling and networking. I would map subscriptions to workloads first, because a subscription is often a billing convenience while an account is a security boundary.
  • "What is a service control policy and how is it different from Azure Policy?" An SCP sets the maximum permissions an account or OU can ever have; it never grants. Azure Policy can audit, modify and deny; on AWS the "detect" part is AWS Config and the "prevent" part is SCPs and IAM conditions.
  • "What breaks first when teams copy an Azure network design?" Overlapping CIDRs with on-premises, assuming subnets span zones, and relying on transitive peering.

Certification practice

Completion checklist

  • I can say in two sentences why an AWS account is a stronger boundary than an Azure subscription
  • I ran the inventory mapper (with sample or real data) and understand the "unmapped" list
  • I listed the AZ IDs for my sandbox Region
  • I confirmed nothing tagged Project=cea-lab is left billing

Key takeaways

  • The account is the AWS unit of security and billing; resource groups have no direct twin.
  • Guardrails flow down as SCPs that only limit; permissions never inherit.
  • Subnets are per-AZ, peering is non-transitive and Regions do not pair.
  • Roles replace managed identities and service-principal secrets; the SDK credential chain mirrors DefaultAzureCredential.
  • Sort every difference into renamed, reshaped or different guarantees, and spend your time on the last two.

Further reading

Independent learning resource — not affiliated with, endorsed or sponsored by Amazon Web Services. AWS and related marks are trademarks of Amazon.com, Inc. or its affiliates. All banking data in examples is fictional. Sample architectures are for learning and are not automatically compliant with GDPR, PCI DSS or any banking regulation.

On this page