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

Rehosting with AWS Application Migration Service

Rehost Windows and Linux servers to Amazon EC2 with AWS Application Migration Service (MGN): set up the staging area, install the replication agent, run test launches, perform and finalise a cut-over, use post-launch actions, and keep a fast rollback.

intermediate⏱ 2 h 30 min🔴 Paid — optionalSAP-C03SAA-C03

Assumes: .NET 10 LTS · AWS SDK for .NET v4 (AWSSDK.Mgn) · AWS CLI v2 · AWS CDK v2 (C#) · Terraform AWS provider v6 · Region us-east-1. Verified against official sources on 2026-11-18.

Learning objectives

By the end of this lesson you can:

  • Explain how AWS Application Migration Service (MGN) replicates a server at block level and launches it as an EC2 instance, including what runs in the staging area.
  • Walk a source server through the MGN lifecycle: initial sync, ready for testing, test in progress, ready for cut-over, cut-over in progress, cut-over complete, and the finalise step.
  • Configure the replication, launch and post-launch templates and group servers into applications and waves.
  • Run a test launch and a cut-over launch, validate them with a checklist, and know exactly when you can still roll back.
  • Query MGN from C# and the CLI, and build a small readiness gate that refuses to cut over servers that are not healthy.

Prerequisites

Cost label: paid. A hands-on rehost needs source servers and replication servers. The free alternative is the design-only walkthrough in this lesson, plus the local readiness-gate code. If you do run a test, deploy and destroy within an hour (see the cost section).

Why this matters in banking

Harbourline's nightly statement batch runs on a Windows Server 2016 virtual machine whose build instructions left the company with the engineer who wrote them. Nobody dares rebuild it. The data-centre exit date is fixed. The honest answer for this server is to rehost: copy the machine as it is, prove it works in AWS, switch over with a short outage, and modernise later.

The risk is not the copy; it is the cut-over. A bank needs a rehearsed procedure: test launches that prove the machine boots and the application works, a freeze window, a final sync, a launch, a validation checklist and a way back. MGN gives the mechanics; this lesson supplies the discipline.

The idea in plain language

MGN installs a small replication agent on each source server. The agent reads the server's disks at the block level (so it is operating-system and application agnostic), copies everything to a lightweight replication server in AWS, and then keeps copying every change. Those blocks land on EBS volumes in a private staging area in your AWS account.

When you ask for a test, MGN creates a point-in-time snapshot of the staged disks, uses a conversion server to make it bootable on EC2 (drivers, boot configuration), and launches a test instance while replication continues undisturbed. Each new test replaces the previous test instance. When you are happy, you run the cut-over: the same launch process, but on a copy of the latest state, and you point users at the new instance. After you confirm it works, you finalise, which stops replication, deletes the staged data and the replication servers, and uninstalls the agent.

Analogy: Photocopying a vault ledger page by page while clerks keep writing in it. The test is a trial binding of the copy, to check the pages are in order. The cut-over is the day you freeze the original, copy the last pages, bind the copy, and open it for business. Finalise is when you finally shred the working copies.

What problem the AWS service solves

MGN solves "copy a running server into EC2 without rebuilding it, with minutes of downtime." The documentation presents it as part of the AWS Transform family and the console is at console.aws.amazon.com/mgn; the service API, CLI (aws mgn) and IAM actions (mgn:*) keep the MGN name ⚠ VERIFY that no renaming reaches the CLI before you script against it.

Honest limits:

  • Rehost means you keep everything: the old OS, the unpatched libraries, the Windows licence cost and the technical debt. MGN moves the problem to a better location; it does not fix it.
  • Replication takes bandwidth. The initial sync copies the whole disk. A 2 TB server over a 1 Gbps link takes hours at best, and your production link is shared. Plan throttling and windows.
  • Not everything replicates well. Very write-heavy databases are better handled by native database replication or DMS (see Database migration), with MGN used for the application tier. Clustered shared-disk servers and some appliance operating systems need design work ⚠ VERIFY the current supported-OS list.
  • The test instance is not a cut-over. It proves bootability and application behaviour, but the dependencies it reaches (DNS, authentication, databases) are those you configured for the test.
  • Region support. MGN supports many Regions including us-east-1 and the London and Ireland Regions Harbourline would use for UK data ⚠ VERIFY that your chosen Region is on the supported list and meets your data-residency approval.

Microsoft / Azure comparison

You know (Microsoft/Azure)AWS equivalentWhat's different
Azure Migrate: Server Migration (replication appliance)AWS Application Migration Service (MGN)MGN is agent-based at block level. Azure Migrate also offers agentless VMware replication; MGN has an agentless VMware path only through other AWS Transform workflows ⚠ VERIFY
Azure Site Recovery (as a migration tool)MGN for migration, AWS Elastic Disaster Recovery for DRBoth AWS services share the same replication engine heritage; MGN post-launch actions can set up Elastic Disaster Recovery
Hyper-V ReplicaMGN or VM Import/ExportVM Import/Export is a one-shot image import, with no continuous replication
Cut-over "test migration" in Azure MigrateMGN test launchEach new test deletes the previous test instance
Azure Hybrid BenefitLicense type setting and BYOL optionsWindows BYOL is restricted; see Windows and SQL Server licensing
Azure Resource Mover / landing zoneStaging area subnet in your landing zone VPCYou supply the subnet and the security groups for replication servers

Architecture

Security-boundary view. Three trust zones exist: the source server (agent credentials, outbound only), the staging subnet (replication servers with no inbound internet access; they receive agent traffic on TCP 1500 and call AWS APIs through endpoints or a NAT path) and the target subnets (where application traffic runs). Replication data is encrypted in transit, and the staged EBS volumes should use a customer-managed KMS key so access to replicated data is a key-policy decision. Use private connectivity (VPN or Direct Connect) for the agent-to-replication-server path rather than the public internet ⚠ VERIFY the port list for your agent version in the MGN network requirements page.

Step-by-step implementation

Prepare the landing zone

Create a staging subnet (private), a target subnet per Availability Zone, and VPC endpoints or a controlled egress path so replication servers can reach the MGN, EC2, S3 and KMS APIs. Tag everything. The IaC section builds this.

Initialise the service and set the templates

Initialise MGN once per Region. Then edit three templates:

  • Replication template: staging subnet, replication server instance type, EBS encryption key, security groups, data routing (private IP over VPN or Direct Connect), bandwidth throttling.
  • Launch template (EC2 launch template under the hood): target instance type, subnet, security groups, licence type, tenancy, tags.
  • Post-launch template: activate it at account level so MGN installs the Systems Manager agent and can run actions after launch.

Install the replication agent

On each source server, install the AWS Replication Agent with credentials created for that purpose. For many servers, MGN connectors automate prerequisite checks and installation. Initial sync begins automatically and the server stays in Not ready until it completes.

Group servers into applications and waves

Associate source servers into applications (servers that belong together, such as a web tier and its batch server) and applications into waves. Launch, cut-over and archive actions work at server, application or wave level, which is how a hundred-server wave stays manageable.

Test launch

When replication reports Healthy and the server is Ready for testing, start a test. Validate with the checklist below. Repeat after fixes: a new test deletes the previous test instance and launches fresh from the latest data.

Cut-over

During the approved window: freeze writes on the source (stop the application and services), wait for replication lag to reach zero, mark the server Ready for cut-over, launch the cut-over instance, repoint DNS and dependants, run the validation checklist and decide go or rollback.

Finalise (and not before)

Only after the business has accepted the result and your rollback window has expired, finalise the cut-over. This stops replication, discards replicated data, terminates replication resources and uninstalls the agent. After this, the source server no longer has a live replica to roll back to; the source machine itself still exists until you decommission it.

The lifecycle at a glance

The test-launch validation checklist

CheckWhy
Instance passes both EC2 status checksOS boots and network works
RDP or SSM Session Manager access worksYou can administer it without a bastion hole
Windows activation and licence type correctLicense-included versus BYOL surprises
Domain join and Kerberos workApplication identity depends on AD (see Network migration)
Services start in order; scheduled tasks presentRehosted servers often rely on boot-time state
Application health endpoint returns healthyBusiness function, not just OS
Outbound dependencies reachable (DB, SMTP, partner SFTP)Security groups and routes differ from on premises
Time sync and time zone correctA ledger that posts at the wrong time is a defect
No outbound connection to production systems from a test instanceA test must not send real emails or payments

That last row is the one that hurts: a test launch is a full copy of a production server, including its scheduled jobs and its credentials. Isolate test instances in a network segment that cannot reach production dependencies unless you intend it.

AWS Console instructions

  • Console → Application Migration Service → Get started (first run initialises the service and creates the required roles).
  • Settings → Replication template → set the staging area subnet, replication server instance type, EBS encryption (choose your KMS key) and data routing → Save template.
  • Settings → Launch template → set subnet, instance type right-sizing, licence type → Save.
  • Settings → Post-launch template → toggle Install Systems Manager agent and allow executing actions on launched servers, then choose the actions and whether they run on test instances, cut-over instances or both.
  • Source servers → select a server → Test and cutover → Launch test instances; later Mark as ready for cutover, Launch cutover instances, and finally Finalize cutover.
  • Applications and Waves pages group servers for bulk operations.

AWS CLI

# One-time per Region: initialise MGN and create service-linked roles.
aws mgn initialize-service --profile learn-sandbox --region us-east-1

# See replication and lifecycle state for every source server.
aws mgn describe-source-servers --profile learn-sandbox --region us-east-1 \
  --query "items[].{id:sourceServerID,host:sourceProperties.identificationHints.hostname,state:lifeCycle.state,repl:dataReplicationInfo.dataReplicationState}" \
  --output table

# Launch a test instance for a server, then check the job.
aws mgn start-test --source-server-ids s-1234567890abcdef0 --profile learn-sandbox --region us-east-1
aws mgn describe-jobs --profile learn-sandbox --region us-east-1

# Tell MGN the test passed and the server is ready for cutover.
aws mgn change-server-life-cycle-state --source-server-id s-1234567890abcdef0 \
  --life-cycle state=READY_FOR_CUTOVER --profile learn-sandbox --region us-east-1

# Cut over (run only inside the approved window).
aws mgn start-cutover --source-server-ids s-1234567890abcdef0 --profile learn-sandbox --region us-east-1

# After acceptance AND after the rollback window: finalise.
aws mgn finalize-cutover --source-server-id s-1234567890abcdef0 --profile learn-sandbox --region us-east-1

⚠ VERIFY every flag against aws mgn help for your CLI version before scripting a wave. The server ID shown is a placeholder.

Infrastructure as Code

MGN's per-server state is runtime data, not infrastructure, so the IaC here builds the staging area: a private VPC segment with an S3 gateway endpoint, flow logs and tags. The MGN templates themselves are created with the console or aws mgn create-replication-configuration-template ⚠ VERIFY whether your CDK and Terraform provider versions expose MGN template resources before moving them into code.

StagingAreaStack.cs
using Amazon.CDK;
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.Logs;
using Constructs;

namespace Harbourline.Migration.Infra;

public sealed class StagingAreaStack : Stack
{
    public StagingAreaStack(Construct scope, string id, IStackProps? props = null)
        : base(scope, id, props)
    {
        var vpc = new Vpc(this, "MigrationVpc", new VpcProps
        {
            IpAddresses = IpAddresses.Cidr("10.60.0.0/20"), // must not overlap on-premises ranges
            MaxAzs = 2,
            NatGateways = 0, // no NAT: reach AWS APIs through endpoints
            SubnetConfiguration =
            [
                new SubnetConfiguration { Name = "staging", SubnetType = SubnetType.PRIVATE_ISOLATED, CidrMask = 24 },
                new SubnetConfiguration { Name = "target",  SubnetType = SubnetType.PRIVATE_ISOLATED, CidrMask = 24 }
            ]
        });

        // S3 gateway endpoint: replication servers download software and write to S3 privately.
        vpc.AddGatewayEndpoint("S3", new GatewayVpcEndpointOptions { Service = GatewayVpcEndpointAwsService.S3 });

        // Interface endpoints for the APIs replication servers call. Verify the full list in the MGN network requirements.
        foreach (var (name, svc) in new[]
        {
            ("Mgn", InterfaceVpcEndpointAwsService.Of("mgn")), // ⚠ VERIFY endpoint service name
            ("Ec2", InterfaceVpcEndpointAwsService.EC2),
            ("Kms", InterfaceVpcEndpointAwsService.KMS)
        })
        {
            vpc.AddInterfaceEndpoint(name + "Endpoint", new InterfaceVpcEndpointOptions { Service = svc });
        }

        var flowLogs = new LogGroup(this, "FlowLogs", new LogGroupProps
        {
            Retention = RetentionDays.THREE_MONTHS, // never infinite
            RemovalPolicy = RemovalPolicy.DESTROY
        });
        vpc.AddFlowLog("All", new FlowLogOptions
        {
            Destination = FlowLogDestination.ToCloudWatchLogs(flowLogs),
            TrafficType = FlowLogTrafficType.ALL
        });

        Amazon.CDK.Tags.Of(this).Add("Project", "cea-lab");
        Amazon.CDK.Tags.Of(this).Add("Lab", "m13-rehost");
        Amazon.CDK.Tags.Of(this).Add("Environment", "learn");
        Amazon.CDK.Tags.Of(this).Add("Owner", "your-name");
    }
}

Complete code

A C# readiness gate: it lists MGN source servers and refuses to approve a cut-over for any server that is not in the correct lifecycle state with healthy replication. The decision logic is a pure function you can unit test without AWS.

CutoverReadiness.csproj
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <RootNamespace>Harbourline.Migration.Readiness</RootNamespace>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="AWSSDK.Mgn" Version="4.*" />
  </ItemGroup>
</Project>
Program.cs
using Amazon.Mgn;
using Amazon.Mgn.Model;
using Harbourline.Migration.Readiness;

// Uses the default credential chain: AWS_PROFILE=learn-sandbox and an SSO login.
using var mgn = new AmazonMgnClient();

var servers = new List<ServerStatus>();
string? token = null;
do
{
    var page = await mgn.DescribeSourceServersAsync(new DescribeSourceServersRequest
    {
        Filters = new DescribeSourceServersRequestFilters(),
        MaxResults = 50,
        NextToken = token
    });

    foreach (var s in page.Items)
    {
        servers.Add(new ServerStatus(
            s.SourceServerID,
            s.SourceProperties?.IdentificationHints?.Hostname ?? "(unknown)",
            s.LifeCycle?.State?.Value ?? "UNKNOWN",
            s.DataReplicationInfo?.DataReplicationState?.Value ?? "UNKNOWN",
            s.DataReplicationInfo?.LagDuration));
    }
    token = page.NextToken;
} while (!string.IsNullOrEmpty(token));

var verdicts = CutoverGate.Evaluate(servers, maxLag: TimeSpan.FromMinutes(5));
foreach (var v in verdicts)
    Console.WriteLine($"{(v.Go ? "GO   " : "NO-GO")} {v.Host,-20} {v.Reason}");

// Exit code 2 lets a pipeline stop before anyone launches cutover instances.
return verdicts.All(v => v.Go) ? 0 : 2;
CutoverGate.cs
using System.Xml;

namespace Harbourline.Migration.Readiness;

public sealed record ServerStatus(
    string Id, string Host, string LifeCycleState, string ReplicationState, string? LagIso8601);

public sealed record Verdict(string Id, string Host, bool Go, string Reason);

public static class CutoverGate
{
    public static IReadOnlyList<Verdict> Evaluate(IEnumerable<ServerStatus> servers, TimeSpan maxLag) =>
        servers.Select(s => Evaluate(s, maxLag)).ToList();

    public static Verdict Evaluate(ServerStatus s, TimeSpan maxLag)
    {
        if (s.LifeCycleState != "READY_FOR_CUTOVER")
            return No(s, $"lifecycle is {s.LifeCycleState}, expected READY_FOR_CUTOVER (was a test completed and accepted?)");

        // CONTINUOUS is the steady state you want. Anything else means the last copy may be stale.
        if (s.ReplicationState != "CONTINUOUS")
            return No(s, $"replication state is {s.ReplicationState}, expected CONTINUOUS");

        if (!TryParseLag(s.LagIso8601, out var lag))
            return No(s, "replication lag is unknown, so data freshness cannot be proven");

        if (lag > maxLag)
            return No(s, $"replication lag {lag} exceeds limit {maxLag}");

        return new Verdict(s.Id, s.Host, true, $"ready, lag {lag}");
    }

    private static bool TryParseLag(string? iso, out TimeSpan lag)
    {
        lag = default;
        if (string.IsNullOrWhiteSpace(iso)) return false;
        try
        {
            // MGN reports durations in ISO 8601 form such as PT3M20S ⚠ VERIFY on a live response.
            lag = XmlConvert.ToTimeSpan(iso);
            return true;
        }
        catch (FormatException)
        {
            return false;
        }
    }

    private static Verdict No(ServerStatus s, string reason) => new(s.Id, s.Host, false, reason);
}

⚠ VERIFY the exact SDK property names and the string values of the lifecycle and replication-state enums against the AWSSDK.Mgn v4 model: the code treats them as strings (.Value) so a renamed enum member fails the gate safely (it says NO-GO) rather than approving a wrong server.

Code explained line by line

  1. new AmazonMgnClient() uses the default credential chain. With SSO, run aws sso login --profile learn-sandbox and set AWS_PROFILE=learn-sandbox. No keys appear in code.
  2. The do … while loop pages through DescribeSourceServers with NextToken, so more than one page of servers is not silently truncated.
  3. Reading .Value from the SDK's string-like constant classes keeps the gate independent of enum member names.
  4. CutoverGate.Evaluate is deliberately fail-closed: every condition that cannot be proven (unknown lag, unparsable duration) returns NO-GO. A bank prefers a blocked cut-over to a cut-over onto stale data.
  5. XmlConvert.ToTimeSpan parses ISO 8601 durations such as PT3M20S, which is how many AWS APIs report intervals.
  6. The program's return code is 0 only if every server is GO, so a pipeline stage or change-board script can act on it.

Security considerations

⚠ Learning shortcut — not for production

The lesson uses one account for staging and targets, a broad operator role, and test instances launched into a subnet you control by hand. In production use a dedicated migration account (or the landing zone's workload accounts) with separate roles for agent installation, replication administration and cut-over approval, so one person cannot both approve and run a cut-over. Use a customer-managed KMS key for staged volumes, restrict who can launch instances, and use SCPs to stop replicated servers from being launched with public IPs.

  • Agent credentials. The installer needs AWS credentials. Use the narrowest MGN-provided installation permissions (the AWS managed policy for agent installation ⚠ VERIFY the exact name), keep them short-lived where the process allows, and rotate or delete them when the wave completes.
  • Copies of production data in a test instance. A test instance contains customer data (UK GDPR applies as soon as it is copied). Restrict who can log on, keep it in an approved Region, and terminate it when testing ends.
  • Post-launch parameters. MGN stores post-launch action parameters in Systems Manager Parameter Store as ordinary strings unless you opt in to KMS encryption. Never put passwords there; reference Secrets Manager instead.
  • Operating system patching. A rehosted server is as vulnerable as before. Plan patching and Inspector scanning in the first week, not "later".

Banking use case

Harbourline's wave 2 holds the Windows statement-batch server and its reporting server (an application of two source servers). The change board approves a three-step plan: two test launches in an isolated subnet, one in the previous Friday's freeze window, and a cut-over on a Saturday. The readiness gate runs the day before and again an hour before the window; at cut-over the batch scheduler is stopped, replication lag falls to seconds, and the cut-over launches. Validation compares the statement count and a control total against the previous Saturday's run. DNS is switched with a low TTL. The old servers stay powered off but intact for two weeks, which is the rollback window, and only then does the team finalise.

Common mistakes

  • Testing once and cutting over in anger. Test launches are cheap and are where you find missing domain trust, wrong security groups and licence prompts.
  • Letting the test instance talk to production. It sends emails, posts transactions and processes queues. Isolate it.
  • Finalising straight after cut-over. Finalising stops replication and removes the replica; your rollback is then the powered-off source only. Wait out the rollback window.
  • Ignoring replication bandwidth. The initial sync saturates a shared link and slows production. Throttle and schedule.
  • Right-sizing by copying the on-premises size. The same vCPU count may cost more or less; use the assessment's right-sizing and compare licence cost.
  • Forgetting the staging subnet's DNS and time sources. Replication servers need working name resolution.

Troubleshooting

SymptomLikely causeFix
Server stuck in Not ready or replication StalledSource cannot reach the replication server on the replication port, or a firewall dropped itCheck routes, security groups, NACLs and on-premises firewall for the replication port and 443
Replication laggingLink saturated or a write-heavy diskRaise bandwidth or schedule, exclude temp disks, or use database-native replication
Test instance fails status checksConversion or driver issue, or wrong instance family for the OS versionCheck the job log items, choose a supported instance type, retry the test
Windows prompts for activationLicense type mismatchReview the launch template licence setting (License Manager conversion options exist)
Application cannot reach its databaseDifferent network path or security group in AWSFix routes and groups, and update connection strings or DNS
Post-launch actions did not runPost-launch settings not activated at account level, or SSM agent not installed or unsupported OSActivate the template and check SSM managed-instance status

Cost and cleanup

Cost: paid for hands-on. While replicating, you pay for the replication servers (small EC2 instances), the staged EBS volumes and snapshots, and data transfer. MGN's own service charge has been free for a limited number of days per server, but the details change ⚠ VERIFY on the current pricing page. A test instance costs the normal EC2 and EBS price for its size, and a Windows licence-included instance costs more than Linux. Free alternative: do the design-only walkthrough (tables, checklist and the gate code above) and unit test CutoverGate locally with fake ServerStatus records.

If you do a hands-on run: use one small non-production Windows or Linux VM, finish the test in under an hour, then clean up.

# Archive the server in MGN, which also disconnects it (do this before deleting AWS resources).
aws mgn disconnect-from-service --source-server-id s-1234567890abcdef0 --profile learn-sandbox
aws mgn mark-as-archived --source-server-id s-1234567890abcdef0 --profile learn-sandbox

# Terminate any test or cutover instance, and delete leftover replication resources and snapshots.
aws ec2 describe-instances --filters Name=tag:Project,Values=cea-lab --profile learn-sandbox \
  --query "Reservations[].Instances[].InstanceId" --output text
aws ec2 terminate-instances --instance-ids i-0123456789abcdef0 --profile learn-sandbox

# Tear down the staging network (CDK or Terraform).
# cdk destroy    or    terraform destroy

# Confirm nothing tagged Project=cea-lab remains.
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab --profile learn-sandbox

Also uninstall the agent from the source server and delete the agent installation credentials.

Exercises

  • 🟢 Guided: Build the readiness gate project, then write three tests (in a separate xUnit test project) that call CutoverGate.Evaluate with a ready server, a lagging server and a server whose lag is null. Confirm the third is NO-GO.
  • 🟡 Challenge: Extend the gate to require that the server belongs to an application whose other servers are also ready (an all-or-nothing application check). Use a Dictionary<string, string> of server to application.
  • 🔴 Live problem: The business wants the statement-batch server cut over on Saturday, but test launch #2 produced statements with the wrong time zone, and the on-premises server cannot be frozen for more than 90 minutes. Write the go/no-go recommendation and the options (fix and retest, move the date, or run in parallel), with the evidence you would ask for.

Assignment

Write a rehost runbook for one fictional Harbourline server in your portfolio repository: prerequisites, template settings, test-launch checklist, cut-over steps with timings, rollback triggers and finalise criteria. Include the gate program as an appendix.

Solutions

Knowledge check

Interview questions

  • Why use block-level replication for a lift and shift? It is agnostic to OS and application, needs no code change and keeps the server consistent as a whole, at the cost of copying everything including the debt.
  • How do you rehearse a cut-over? Repeated test launches in an isolated network, a timed checklist, a measured freeze duration, and a rollback drill.
  • What is your rollback if the cut-over instance fails an hour after go-live? Repoint DNS back to the intact source server (if no data diverged), or accept forward-fix; the choice depends on whether the instance has taken new writes. The plan must state this before the window.

Certification practice

Completion checklist

  • I can describe the replication path and what runs in the staging area
  • I can list the MGN lifecycle states in order
  • I built the readiness gate and its tests
  • I know why finalise must wait for the rollback window
  • I ran the cleanup steps and confirmed nothing is still billing

Key takeaways

  • MGN copies blocks continuously; test launches prove the copy; the cut-over launches the latest state.
  • Finalise only after acceptance and after the rollback window.
  • Test instances are production copies. Isolate them.
  • Gate cut-overs fail-closed on lifecycle, replication state and lag.
  • Rehost preserves debt and licence cost; it is a first step, not the end.

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