<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Emmanuel R</title>
    <description>The latest articles on DEV Community by Emmanuel R (@emmanuelldev).</description>
    <link>https://dev.to/emmanuelldev</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4146599%2F6aaae253-0310-42b2-8d55-7d4533d370a6.jpg</url>
      <title>DEV Community: Emmanuel R</title>
      <link>https://dev.to/emmanuelldev</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/emmanuelldev"/>
    <language>en</language>
    <item>
      <title>When Terraform Plans Lie: Two GKE Issues and How to Catch Them</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Thu, 05 Nov 2026 09:23:34 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/when-terraform-plans-lie-two-gke-issues-and-how-to-catch-them-1j1l</link>
      <guid>https://dev.to/cobuildx-ai/when-terraform-plans-lie-two-gke-issues-and-how-to-catch-them-1j1l</guid>
      <description>&lt;p&gt;&lt;em&gt;A provider bug that wipes a GKE cluster's disruption budget, and a module bug whose plan never settles. We trace both to the provider and module source, reproduce them in a throwaway project, weigh the workarounds, and build the post-apply gate that catches this whole class of drift.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Here is a sprint that looks routine. A platform team runs four GKE clusters from Terraform. One is a production Autopilot cluster in &lt;code&gt;us-central1&lt;/code&gt; running stateful services that take a long time to rebalance after a node restart, so it carries a disruption budget: at least 45 days between minor upgrades and 3 days between patch upgrades. The other three are Standard private clusters built from the community module's &lt;code&gt;beta-private-cluster-update-variant&lt;/code&gt;. CI posts a plan on every pull request, applies on merge, and a nightly job runs &lt;code&gt;terraform plan -detailed-exitcode&lt;/code&gt; on all four stacks and pages someone if the plan is not empty.&lt;/p&gt;

&lt;p&gt;Two changes go in that sprint. The production cluster moves to a &lt;code&gt;recurring_maintenance_window&lt;/code&gt;, the newer window type with an explicit start time and duration that landed in the provider source in July 2026. The private clusters get &lt;code&gt;enable_private_endpoint = true&lt;/code&gt;, so the control plane is reachable only from inside the VPC. Both plans look right. Both applies succeed.&lt;/p&gt;

&lt;p&gt;Afterwards, the production cluster has quietly lost its disruption budget, and the three private clusters show the same one-line diff every night that no apply ever clears. That is roughly 90 drift pages a month (3 stacks, 30 nights) that mean nothing, plus one missing setting on the cluster that matters most.&lt;/p&gt;

&lt;p&gt;This is a representative scenario, not a customer engagement, but both failures are real and open upstream: &lt;a href="https://github.com/hashicorp/terraform-provider-google/issues/30554" rel="noopener noreferrer"&gt;terraform-provider-google #30554&lt;/a&gt; and &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/issues/2697" rel="noopener noreferrer"&gt;terraform-google-kubernetes-engine #2697&lt;/a&gt;, both filed on 3 November 2026. Below we work through each one: what the reporter saw, what the source code says, how to reproduce it in a throwaway project, which workaround we would pick and what it costs, and the post-apply gate that catches both.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Key takeaways&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;#30554:&lt;/strong&gt; the provider's &lt;code&gt;recurring_maintenance_window&lt;/code&gt; branch never sends &lt;code&gt;disruption_budget&lt;/code&gt; to GKE and never reads it back. A budget set outside Terraform is wiped without a diff. One set in Terraform, by our reading of the code, never converges.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;#2697:&lt;/strong&gt; the private-cluster module variants render an empty &lt;code&gt;master_authorized_networks_config {}&lt;/code&gt; whenever &lt;code&gt;enable_private_endpoint = true&lt;/code&gt;. GKE stores nothing for it, so every plan tries to add it again.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Best workaround for #30554:&lt;/strong&gt; express the same window as &lt;code&gt;recurring_window&lt;/code&gt;, whose code path does carry the budget. Setting the budget with &lt;code&gt;gcloud&lt;/code&gt; alone gets wiped on the next maintenance policy change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The gate that catches both:&lt;/strong&gt; read the live cluster after &lt;code&gt;apply&lt;/code&gt; and require a second plan to exit 0. A check that reads through the same provider shares its blind spot.&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Bug 1: the budget the provider never sends
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What the reporter saw
&lt;/h3&gt;

&lt;p&gt;The report is against &lt;code&gt;hashicorp/google&lt;/code&gt; v8.10.0 and Terraform v1.14.0, reproduced on a real Autopilot cluster. The steps: start with a cluster that has a disruption budget, confirm it in the maintenance policy, configure &lt;code&gt;recurring_maintenance_window&lt;/code&gt; on the &lt;code&gt;google_container_cluster&lt;/code&gt; resource, apply, and inspect the policy again. The budget is gone. The reporter's config sets both blocks:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_container_cluster"&lt;/span&gt; &lt;span class="s2"&gt;"example"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;             &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"example-cluster"&lt;/span&gt;
  &lt;span class="nx"&gt;location&lt;/span&gt;         &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"us-central1"&lt;/span&gt;
  &lt;span class="nx"&gt;enable_autopilot&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;

  &lt;span class="nx"&gt;maintenance_policy&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;recurring_maintenance_window&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nx"&gt;window_start_time&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nx"&gt;hours&lt;/span&gt;   &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;
        &lt;span class="nx"&gt;minutes&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
        &lt;span class="nx"&gt;seconds&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
      &lt;span class="p"&gt;}&lt;/span&gt;
      &lt;span class="nx"&gt;window_duration&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"4h"&lt;/span&gt;
      &lt;span class="nx"&gt;recurrence&lt;/span&gt;      &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"FREQ=DAILY"&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="nx"&gt;disruption_budget&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nx"&gt;minor_version_disruption_interval&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"3888000s"&lt;/span&gt; &lt;span class="c1"&gt;# 45 days&lt;/span&gt;
      &lt;span class="nx"&gt;patch_version_disruption_interval&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"259200s"&lt;/span&gt;  &lt;span class="c1"&gt;# 3 days&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The reporter traced it to two functions in the provider source and noted that the equivalent handling already exists for &lt;code&gt;daily_maintenance_window&lt;/code&gt; and &lt;code&gt;recurring_window&lt;/code&gt;. They did not post plan output, so what Terraform shows before and after the apply is not part of the report. That gap matters, and we come back to it below.&lt;/p&gt;

&lt;h3&gt;
  
  
  What the source says
&lt;/h3&gt;

&lt;p&gt;We read &lt;code&gt;resource_container_cluster.go.tmpl&lt;/code&gt; in &lt;a href="https://github.com/GoogleCloudPlatform/magic-modules/blob/main/mmv1/third_party/terraform/services/container/resource_container_cluster.go.tmpl" rel="noopener noreferrer"&gt;magic-modules&lt;/a&gt; on &lt;code&gt;main&lt;/code&gt; as of 5 November 2026, which is where the provider's container code is generated from. The reporter's diagnosis holds. &lt;code&gt;expandMaintenancePolicy()&lt;/code&gt; builds a &lt;code&gt;budget&lt;/code&gt; value once, then returns from one of three branches. The daily and &lt;code&gt;recurring_window&lt;/code&gt; branches both set &lt;code&gt;DisruptionBudget: budget&lt;/code&gt;. The &lt;code&gt;recurring_maintenance_window&lt;/code&gt; branch builds its policy without it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="c"&gt;// recurring_window branch: budget included&lt;/span&gt;
&lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;container&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;MaintenancePolicy&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Window&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;container&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;MaintenanceWindow&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="c"&gt;/* RecurringWindow ... */&lt;/span&gt; &lt;span class="p"&gt;},&lt;/span&gt;
    &lt;span class="n"&gt;DisruptionBudget&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;budget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;ResourceVersion&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;  &lt;span class="n"&gt;resourceVersion&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="c"&gt;// recurring_maintenance_window branch: budget computed above, never attached&lt;/span&gt;
&lt;span class="n"&gt;policy&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;container&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;MaintenancePolicy&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Window&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;container&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;MaintenanceWindow&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="c"&gt;/* RecurringMaintenanceWindow ... */&lt;/span&gt; &lt;span class="p"&gt;},&lt;/span&gt;
    &lt;span class="n"&gt;ResourceVersion&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="n"&gt;resourceVersion&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;flattenMaintenancePolicy()&lt;/code&gt; mirrors it. It builds a &lt;code&gt;budget&lt;/code&gt; list from the API response, adds &lt;code&gt;"disruption_budget": budget&lt;/code&gt; to the daily and &lt;code&gt;recurring_window&lt;/code&gt; results, and leaves it out of the &lt;code&gt;recurring_maintenance_window&lt;/code&gt; result. The fix is two lines, one in each function.&lt;/p&gt;

&lt;p&gt;One more detail explains why an existing budget disappears rather than just failing to update. Changes to &lt;code&gt;maintenance_policy&lt;/code&gt; go through GKE's &lt;code&gt;SetMaintenancePolicy&lt;/code&gt; call with the whole policy object. A policy sent without a budget replaces one that had a budget. GKE then falls back to its defaults, which the &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/how-to/cluster-disruption-budget" rel="noopener noreferrer"&gt;cluster disruption budget docs&lt;/a&gt; give as 24 hours between patch upgrades and 30 days between minor upgrades. In our scenario that means patch upgrades can land a day apart instead of three, and minor upgrades 30 days apart instead of 45.&lt;/p&gt;

&lt;h3&gt;
  
  
  Two cases, two symptoms
&lt;/h3&gt;

&lt;p&gt;Whether the plan shows anything depends on where the budget lives. &lt;code&gt;disruption_budget&lt;/code&gt; is &lt;code&gt;Optional&lt;/code&gt; but not &lt;code&gt;Computed&lt;/code&gt; in the schema. Read that against the flatten bug and you get two different symptoms:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Where the budget is set&lt;/th&gt;
&lt;th&gt;What apply does&lt;/th&gt;
&lt;th&gt;What the next plan shows&lt;/th&gt;
&lt;th&gt;Source&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Outside Terraform (&lt;code&gt;gcloud&lt;/code&gt; or console), not in config&lt;/td&gt;
&lt;td&gt;Sends a policy with no budget. GKE replaces the policy and the budget is gone&lt;/td&gt;
&lt;td&gt;Nothing. Config has no budget, state has no budget, so there is nothing to compare&lt;/td&gt;
&lt;td&gt;Matches the reporter's reproduction steps&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;In the &lt;code&gt;disruption_budget&lt;/code&gt; block, as in the reporter's config&lt;/td&gt;
&lt;td&gt;Budget is never sent, so the cluster runs on defaults&lt;/td&gt;
&lt;td&gt;Should show &lt;code&gt;+ disruption_budget&lt;/code&gt; on every plan, because flatten never writes it to state. Applying sends the same budget-less request again&lt;/td&gt;
&lt;td&gt;Our reading of the code. Not stated in the issue. Confirm with the reproduction below&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The first case is the dangerous one: a setting someone added by hand, perhaps during an incident, is removed by an unrelated Terraform change and nothing says so. The second case is noisier but still misleading. The diff says Terraform is about to add the budget. The apply succeeds, and the budget still is not there.&lt;/p&gt;

&lt;h3&gt;
  
  
  Reproduce it, then confirm a fix
&lt;/h3&gt;

&lt;p&gt;Do this in a throwaway project, not by experimenting on production. An Autopilot cluster is enough. Pin the provider to the version you run (&lt;code&gt;8.10.0&lt;/code&gt; in the report), and keep the reproduction to one resource so nothing else in your stack affects the result:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# 0. Baseline: daily window plus budget. This code path carries the budget.&lt;/span&gt;
terraform apply &lt;span class="nt"&gt;-auto-approve&lt;/span&gt;
gcloud container clusters describe repro &lt;span class="nt"&gt;--location&lt;/span&gt; us-central1 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--format&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'yaml(maintenancePolicy.disruptionBudget)'&lt;/span&gt;
&lt;span class="c"&gt;# expect minorVersionDisruptionInterval: 3888000s, patchVersionDisruptionInterval: 259200s&lt;/span&gt;

&lt;span class="c"&gt;# 1. Case A: swap daily_maintenance_window for recurring_maintenance_window, keep the budget block.&lt;/span&gt;
terraform apply &lt;span class="nt"&gt;-auto-approve&lt;/span&gt;
gcloud container clusters describe repro &lt;span class="nt"&gt;--location&lt;/span&gt; us-central1 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--format&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'yaml(maintenancePolicy.disruptionBudget)'&lt;/span&gt;
&lt;span class="c"&gt;# bug present: empty output&lt;/span&gt;
terraform plan &lt;span class="nt"&gt;-detailed-exitcode&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"exit=&lt;/span&gt;&lt;span class="nv"&gt;$?&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;
&lt;span class="c"&gt;# bug present (by our reading): exit=2 with "+ disruption_budget"&lt;/span&gt;

&lt;span class="c"&gt;# 2. Case B: delete the budget block from config, set it out of band, then change the window.&lt;/span&gt;
gcloud container clusters update repro &lt;span class="nt"&gt;--location&lt;/span&gt; us-central1 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--maintenance-minor-version-disruption-interval&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;3888000s &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--maintenance-patch-version-disruption-interval&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;259200s
&lt;span class="c"&gt;# edit window_duration from "4h" to "5h"&lt;/span&gt;
terraform apply &lt;span class="nt"&gt;-auto-approve&lt;/span&gt;
gcloud container clusters describe repro &lt;span class="nt"&gt;--location&lt;/span&gt; us-central1 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--format&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'yaml(maintenancePolicy.disruptionBudget)'&lt;/span&gt;
&lt;span class="c"&gt;# bug present: empty output, and the plan above it showed only the window change&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A fixed provider passes when step 1 shows the budget in &lt;code&gt;gcloud&lt;/code&gt; and the follow-up plan exits 0. Case B will still remove an out-of-band budget even after the fix, because the policy is replaced as a whole. That is how &lt;code&gt;SetMaintenancePolicy&lt;/code&gt; behaves, not a bug. If a setting matters, it belongs in config.&lt;/p&gt;

&lt;p&gt;To test a patched provider before a release ships, build it from a branch and point Terraform at the binary with a &lt;a href="https://developer.hashicorp.com/terraform/cli/config/config-file#development-overrides-for-provider-developers" rel="noopener noreferrer"&gt;&lt;code&gt;dev_overrides&lt;/code&gt;&lt;/a&gt; block in your CLI config. Run the same script against it. That is fine for proving a fix. It is not how you should run production.&lt;/p&gt;

&lt;h3&gt;
  
  
  Workarounds, and what each one costs
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Option&lt;/th&gt;
&lt;th&gt;Does the cluster get the budget?&lt;/th&gt;
&lt;th&gt;Who owns it&lt;/th&gt;
&lt;th&gt;Cost and risk&lt;/th&gt;
&lt;th&gt;Pick it when&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Express the window as &lt;code&gt;recurring_window&lt;/code&gt; (start, end, RRULE) instead&lt;/td&gt;
&lt;td&gt;Yes. This branch sends and reads the budget&lt;/td&gt;
&lt;td&gt;Terraform&lt;/td&gt;
&lt;td&gt;Different syntax: absolute RFC 3339 start and end times instead of time of day plus duration. Easy to switch back later&lt;/td&gt;
&lt;td&gt;Almost always. This is our default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Keep &lt;code&gt;recurring_maintenance_window&lt;/code&gt;, set budget with &lt;code&gt;gcloud&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Until the next &lt;code&gt;maintenance_policy&lt;/code&gt; change in Terraform, which wipes it silently&lt;/td&gt;
&lt;td&gt;Nobody, in practice&lt;/td&gt;
&lt;td&gt;This is exactly Case B. Any window tweak removes the budget again&lt;/td&gt;
&lt;td&gt;Only as an emergency stopgap, with a verification check and a ticket&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;lifecycle { ignore_changes = [maintenance_policy] }&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;No. Hides the Case A diff, still never sends the budget&lt;/td&gt;
&lt;td&gt;Terraform, nominally&lt;/td&gt;
&lt;td&gt;Also hides every real change to windows and exclusions&lt;/td&gt;
&lt;td&gt;Never for this bug&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Patched provider via &lt;code&gt;dev_overrides&lt;/code&gt; or a private registry&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;You, for every future provider release&lt;/td&gt;
&lt;td&gt;You build, sign and distribute a provider binary and rebase it until upstream merges&lt;/td&gt;
&lt;td&gt;Only to validate a fix, or if you already run a provider fork&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pin an older provider version&lt;/td&gt;
&lt;td&gt;Unknown&lt;/td&gt;
&lt;td&gt;Terraform&lt;/td&gt;
&lt;td&gt;The field only arrived in July 2026 (&lt;a href="https://github.com/GoogleCloudPlatform/magic-modules/pull/17899" rel="noopener noreferrer"&gt;magic-modules #17899&lt;/a&gt;) and the broken branch is still on &lt;code&gt;main&lt;/code&gt;. Older versions have no such field to fall back to, so pinning means switching window type anyway&lt;/td&gt;
&lt;td&gt;Not useful here&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;In the scenario, the production cluster's weekend window becomes this, which keeps the budget in the code path that works:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight hocon"&gt;&lt;code&gt;&lt;span class="nl"&gt;maintenance_policy&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;recurring_window&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;start_time&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"2026-11-07T02:00:00Z"&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;end_time&lt;/span&gt;&lt;span class="w"&gt;   &lt;/span&gt;&lt;span class="p"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"2026-11-07T06:00:00Z"&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;recurrence&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"FREQ=WEEKLY;BYDAY=SA,SU"&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;

  &lt;/span&gt;&lt;span class="nl"&gt;disruption_budget&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;minor_version_disruption_interval&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"3888000s"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="c1"&gt;# 45 days&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;patch_version_disruption_interval&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"259200s"&lt;/span&gt;&lt;span class="w"&gt;  &lt;/span&gt;&lt;span class="c1"&gt;# 3 days&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Two weekend windows of 4 hours give about 104 hours of maintenance availability in any 92-day period, comfortably above the 48 hours GKE requires, and each window meets the 4-hour minimum from the &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/how-to/maintenance-windows-and-exclusions" rel="noopener noreferrer"&gt;maintenance window docs&lt;/a&gt;. Switching window types sends a full &lt;code&gt;SetMaintenancePolicy&lt;/code&gt;, so run the verification script below straight after this apply too.&lt;/p&gt;

&lt;h2&gt;
  
  
  Bug 2: the empty block that never lands
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What the reporter saw
&lt;/h3&gt;

&lt;p&gt;The report is against &lt;code&gt;beta-private-cluster-update-variant&lt;/code&gt; v44.3.0 with &lt;code&gt;hashicorp/google&lt;/code&gt; 7.35.0 and Terraform 1.14. The same condition is in v47.0.0 and &lt;code&gt;master&lt;/code&gt;. With &lt;code&gt;enable_private_endpoint = true&lt;/code&gt; and neither &lt;code&gt;master_authorized_networks&lt;/code&gt; nor &lt;code&gt;gcp_public_cidrs_access_enabled&lt;/code&gt; set, every plan shows:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;  &lt;span class="err"&gt;~&lt;/span&gt; &lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_container_cluster"&lt;/span&gt; &lt;span class="s2"&gt;"primary"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="p"&gt;...&lt;/span&gt;
      &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nx"&gt;master_authorized_networks_config&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Applying changes nothing, and the next plan shows the same diff. The cause, from reading the module, is the &lt;code&gt;for_each&lt;/code&gt; that decides whether to render the block:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="nx"&gt;dynamic&lt;/span&gt; &lt;span class="s2"&gt;"master_authorized_networks_config"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;for_each&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;enable_private_endpoint&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;gcp_public_cidrs_access_enabled&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="kc"&gt;null&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nx"&gt;length&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;master_authorized_networks&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="o"&gt;?&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
  &lt;span class="nx"&gt;content&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;gcp_public_cidrs_access_enabled&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;gcp_public_cidrs_access_enabled&lt;/span&gt;
    &lt;span class="nx"&gt;dynamic&lt;/span&gt; &lt;span class="s2"&gt;"cidr_blocks"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="p"&gt;...&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The private endpoint flag alone makes the condition true, so an empty block goes out. For the affected cluster, &lt;code&gt;gcloud ... --format='yaml(masterAuthorizedNetworksConfig)'&lt;/code&gt; returns nothing, so state never holds the block and each plan wants to add it. The reporter proposes dropping &lt;code&gt;var.enable_private_endpoint ||&lt;/code&gt; or rendering the block only when it carries a setting. They are careful about what they did not check: they do not know why the clause was added, they did not verify whether the provider or API also contributes to the diff, and they only read this one variant.&lt;/p&gt;

&lt;h3&gt;
  
  
  Filling in what the report left open
&lt;/h3&gt;

&lt;p&gt;We followed up on those three open points on 5 November 2026.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Other variants:&lt;/strong&gt; the condition comes from the shared template &lt;code&gt;autogen/main/cluster.tf.tmpl&lt;/code&gt;, which adds &lt;code&gt;var.enable_private_endpoint ||&lt;/code&gt; only for private clusters. On &lt;code&gt;master&lt;/code&gt; it is present in &lt;code&gt;private-cluster&lt;/code&gt;, &lt;code&gt;private-cluster-update-variant&lt;/code&gt;, &lt;code&gt;beta-private-cluster&lt;/code&gt;, &lt;code&gt;beta-private-cluster-update-variant&lt;/code&gt; and &lt;code&gt;beta-autopilot-private-cluster&lt;/code&gt;. The root module and &lt;code&gt;beta-public-cluster&lt;/code&gt; do not have it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Why the clause exists:&lt;/strong&gt; it arrived in &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/pull/2058" rel="noopener noreferrer"&gt;#2058&lt;/a&gt;, merged in August 2024, titled "allow enable_private_endpoint with no master_authorized_networks". The PR description does not say what failed before it. So dropping the clause could regress whatever #2058 fixed. A fork needs to test cluster creation from scratch, not only plans on existing clusters.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Related work:&lt;/strong&gt; open PR &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/pull/2687" rel="noopener noreferrer"&gt;#2687&lt;/a&gt; stops rendering the block when &lt;code&gt;ip_endpoints_enabled = false&lt;/code&gt; (DNS-only control planes), following the same symptom in &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/issues/2460" rel="noopener noreferrer"&gt;#2460&lt;/a&gt;. By its own table it leaves the default &lt;code&gt;ip_endpoints_enabled = null&lt;/code&gt; case unchanged, so it would not fix the configuration in #2697.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The provider side:&lt;/strong&gt; in the provider, an empty block expands to an authorized networks config with &lt;code&gt;Enabled: true&lt;/code&gt; and no CIDR blocks. On read, flatten returns nothing when the API's config is absent or disabled. The provider reads it from &lt;code&gt;controlPlaneEndpointsConfig.ipEndpointsConfig.authorizedNetworksConfig&lt;/code&gt;, while the reporter checked the top-level &lt;code&gt;masterAuthorizedNetworksConfig&lt;/code&gt;. If the API does not keep &lt;code&gt;enabled: true&lt;/code&gt; with zero CIDRs for this cluster shape, the result is the diff the reporter saw. We have not confirmed which layer drops it. The raw-resource reproduction below is how you would tell.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Reproduce it, and isolate the layer
&lt;/h3&gt;

&lt;p&gt;Two runs separate the module from the provider and API. First, the raw resource, with no module involved:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_container_cluster"&lt;/span&gt; &lt;span class="s2"&gt;"repro"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;               &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"mancfg-repro"&lt;/span&gt;
  &lt;span class="nx"&gt;location&lt;/span&gt;           &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"us-central1"&lt;/span&gt;
  &lt;span class="nx"&gt;initial_node_count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
  &lt;span class="c1"&gt;# network, subnetwork and ip_allocation_policy as in your environment&lt;/span&gt;

  &lt;span class="nx"&gt;private_cluster_config&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;enable_private_nodes&lt;/span&gt;    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
    &lt;span class="nx"&gt;enable_private_endpoint&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
    &lt;span class="nx"&gt;master_ipv4_cidr_block&lt;/span&gt;  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"172.16.0.32/28"&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;

  &lt;span class="nx"&gt;master_authorized_networks_config&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Apply, then run &lt;code&gt;terraform plan -detailed-exitcode&lt;/code&gt; from a host inside the VPC. If it exits 2 with &lt;code&gt;+ master_authorized_networks_config {}&lt;/code&gt;, the empty block does not survive the provider and API round trip on its own, and any module that emits it will never converge. If it exits 0, the problem is specific to how the module builds the block. Either way, also dump both API paths with &lt;code&gt;gcloud ... --format=json | jq '{top: .masterAuthorizedNetworksConfig, nested: .controlPlaneEndpointsConfig.ipEndpointsConfig.authorizedNetworksConfig}'&lt;/code&gt; so you know what GKE actually stored.&lt;/p&gt;

&lt;p&gt;Second, the module run: the reporter's module block at v44.3.0, then the same block pointed at a vendored copy with the clause removed. The fix passes when the vendored copy plans to exit 0 on the existing cluster and creates a fresh cluster cleanly, which is the #2058 regression check.&lt;/p&gt;

&lt;h3&gt;
  
  
  Workarounds, and what each one costs
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Option&lt;/th&gt;
&lt;th&gt;Removes the diff?&lt;/th&gt;
&lt;th&gt;Cost and risk&lt;/th&gt;
&lt;th&gt;Pick it when&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Set &lt;code&gt;master_authorized_networks&lt;/code&gt; to real CIDRs&lt;/td&gt;
&lt;td&gt;Yes, the block now carries data&lt;/td&gt;
&lt;td&gt;Changes access policy. Only right if you wanted authorized networks anyway, for example to restrict the private endpoint&lt;/td&gt;
&lt;td&gt;You already meant to restrict control plane access&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Vendor or fork the module and drop the clause&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;You carry a patch across module releases. Regenerate from &lt;code&gt;autogen&lt;/code&gt;, not by hand-editing one variant. Retest cluster creation for the #2058 case&lt;/td&gt;
&lt;td&gt;The diff is breaking your drift alerts and upstream has not merged a fix&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;ignore_changes&lt;/code&gt; on the module's resource&lt;/td&gt;
&lt;td&gt;Not possible from outside a module&lt;/td&gt;
&lt;td&gt;Inside a fork it would also hide real authorized network changes later&lt;/td&gt;
&lt;td&gt;Never&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Allowlist the known diff in CI&lt;/td&gt;
&lt;td&gt;Hides it from the gate, not from the plan&lt;/td&gt;
&lt;td&gt;Allowlists rot. Reviewers still see the noise in PR plans&lt;/td&gt;
&lt;td&gt;Short-lived bridge while a fork or fix lands&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Live with it&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;Noisy nightly drift job, reviewers trained to skim plans&lt;/td&gt;
&lt;td&gt;Never on clusters that matter&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Because &lt;code&gt;master_authorized_networks_config&lt;/code&gt; is &lt;code&gt;Optional&lt;/code&gt; and &lt;code&gt;Computed&lt;/code&gt; in the provider schema, removing the block from config produces no diff even if the cluster has authorized networks enabled. Terraform simply stops managing it. That makes the fork safe to roll out, but it also means Terraform will not notice if someone later enables authorized networks by hand. If that matters, set the networks explicitly instead.&lt;/p&gt;

&lt;p&gt;In the scenario we would vendor the module with the clause removed, since the team does not want authorized networks on a VPC-only endpoint. We would pin the vendored copy by commit, link it to #2697, and add a check that fails when the upstream release containing a fix is available, so the fork does not outlive its reason.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why this class of bug exists
&lt;/h2&gt;

&lt;p&gt;Both bugs live in the round trip between three representations: your HCL config, the API request and response, and Terraform state. Providers built on the Terraform plugin SDK convert between them with hand-written &lt;code&gt;expand&lt;/code&gt; functions (config to API) and &lt;code&gt;flatten&lt;/code&gt; functions (API to state). &lt;code&gt;terraform plan&lt;/code&gt; only compares config with state. If a value is lost on the way out, or an empty value cannot come back, the plan stops describing the cluster.&lt;/p&gt;

&lt;p&gt;For a budget set outside Terraform, which is the reporter's reproduction, and for the empty authorized networks block, the round trip looks like this:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ff4kezd1ol2m0idg8stkp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ff4kezd1ol2m0idg8stkp.png" alt="Diagram of the Terraform round trip: config is expanded into an API request to the GKE API, and the API response is flattened back into Terraform state. Issue 30554, a provider bug: the recurring_maintenance_window branch never sends disruption_budget and never reads it back, so the cluster loses the budget, state never notices and the plan stays empty. Issue 2697, a module bug: the module sends an empty master_authorized_networks_config block, the API stores nothing, state never gets the block and every plan tries to add it again" width="800" height="315"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Four mechanics produce almost every case we have seen of this class:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Branchy expand and flatten.&lt;/strong&gt; When a block has mutually exclusive variants (&lt;code&gt;ExactlyOneOf&lt;/code&gt; across &lt;code&gt;daily_maintenance_window&lt;/code&gt;, &lt;code&gt;recurring_window&lt;/code&gt; and &lt;code&gt;recurring_maintenance_window&lt;/code&gt;), each variant gets its own branch, and shared siblings like &lt;code&gt;disruption_budget&lt;/code&gt; have to be wired into every one. A newly added branch is where a sibling gets missed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Whole-object update calls.&lt;/strong&gt; &lt;code&gt;SetMaintenancePolicy&lt;/code&gt; replaces the policy. Anything the request omits is deleted, including settings Terraform was never told about.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Empty nested blocks.&lt;/strong&gt; An empty block is present in HCL, but the Go API clients omit zero values unless a field is listed in &lt;code&gt;ForceSendFields&lt;/code&gt;, and an API may normalise a config with nothing in it back to absent. The provider authors know this: a comment in &lt;code&gt;expandMasterAuthorizedNetworksConfig&lt;/code&gt; notes that "the GKE API pays attention to the field presence". Presence that the API does not keep cannot round-trip.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Schema flags that decide visibility.&lt;/strong&gt; &lt;code&gt;Optional&lt;/code&gt; without &lt;code&gt;Computed&lt;/code&gt; means state lacking a configured value shows as a diff. &lt;code&gt;Optional&lt;/code&gt; plus &lt;code&gt;Computed&lt;/code&gt; means omitting a block is silent, so Terraform stops owning it. Neither flag helps when flatten drops the value: the plan is either always dirty or always clean, and neither matches the cluster.&lt;/li&gt;
&lt;/ol&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;A check that reads through the same provider has the same blind spot.&lt;/strong&gt; The &lt;code&gt;google_container_cluster&lt;/code&gt; data source calls the resource's read function, so it flattens &lt;code&gt;maintenance_policy&lt;/code&gt; with the same code and would not show the missing budget either.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  The post-apply gate
&lt;/h2&gt;

&lt;p&gt;The guard is not more careful plan review. It is two independent checks run straight after every &lt;code&gt;apply&lt;/code&gt;: read the live resource through a path that does not use the provider, and require a second plan to be empty. This script does both for the scenario's production cluster:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;#!/usr/bin/env bash&lt;/span&gt;
&lt;span class="c"&gt;# verify-gke.sh CLUSTER LOCATION WANT_MINOR WANT_PATCH&lt;/span&gt;
&lt;span class="c"&gt;# Run in the Terraform working directory, straight after apply.&lt;/span&gt;
&lt;span class="nb"&gt;set&lt;/span&gt; &lt;span class="nt"&gt;-euo&lt;/span&gt; pipefail
&lt;span class="nv"&gt;CLUSTER&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$1&lt;/span&gt; &lt;span class="nv"&gt;LOCATION&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$2&lt;/span&gt; &lt;span class="nv"&gt;WANT_MINOR&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$3&lt;/span&gt; &lt;span class="nv"&gt;WANT_PATCH&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$4&lt;/span&gt;
&lt;span class="nv"&gt;fail&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;0

&lt;span class="nv"&gt;desc&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="si"&gt;$(&lt;/span&gt;gcloud container clusters describe &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$CLUSTER&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="nt"&gt;--location&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$LOCATION&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="nt"&gt;--format&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;json&lt;span class="si"&gt;)&lt;/span&gt;

&lt;span class="c"&gt;# 1. Live disruption budget, read from the API, not from Terraform state.&lt;/span&gt;
&lt;span class="nv"&gt;minor&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="si"&gt;$(&lt;/span&gt;jq &lt;span class="nt"&gt;-r&lt;/span&gt; &lt;span class="s1"&gt;'.maintenancePolicy.disruptionBudget.minorVersionDisruptionInterval // "unset"'&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;lt;&amp;lt;&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$desc&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="si"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;patch&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="si"&gt;$(&lt;/span&gt;jq &lt;span class="nt"&gt;-r&lt;/span&gt; &lt;span class="s1"&gt;'.maintenancePolicy.disruptionBudget.patchVersionDisruptionInterval // "unset"'&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;lt;&amp;lt;&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$desc&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="si"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;[[&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$minor&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$WANT_MINOR&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="o"&gt;]]&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="o"&gt;{&lt;/span&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"FAIL minor interval: want &lt;/span&gt;&lt;span class="nv"&gt;$WANT_MINOR&lt;/span&gt;&lt;span class="s2"&gt;, live &lt;/span&gt;&lt;span class="nv"&gt;$minor&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nv"&gt;fail&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;1&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="o"&gt;}&lt;/span&gt;
&lt;span class="o"&gt;[[&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$patch&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$WANT_PATCH&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; &lt;span class="o"&gt;]]&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="o"&gt;{&lt;/span&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"FAIL patch interval: want &lt;/span&gt;&lt;span class="nv"&gt;$WANT_PATCH&lt;/span&gt;&lt;span class="s2"&gt;, live &lt;/span&gt;&lt;span class="nv"&gt;$patch&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nv"&gt;fail&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;1&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="o"&gt;}&lt;/span&gt;

&lt;span class="c"&gt;# 2. Authorized networks at both API paths, for the record.&lt;/span&gt;
jq &lt;span class="nt"&gt;-c&lt;/span&gt; &lt;span class="s1"&gt;'{top: .masterAuthorizedNetworksConfig,
        nested: .controlPlaneEndpointsConfig.ipEndpointsConfig.authorizedNetworksConfig}'&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;lt;&amp;lt;&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$desc&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;

&lt;span class="c"&gt;# 3. Convergence: a second plan must be empty.&lt;/span&gt;
&lt;span class="nb"&gt;set&lt;/span&gt; +e
terraform plan &lt;span class="nt"&gt;-detailed-exitcode&lt;/span&gt; &lt;span class="nt"&gt;-input&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nb"&gt;false&lt;/span&gt; &lt;span class="nt"&gt;-out&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;recheck.tfplan &lt;span class="o"&gt;&amp;gt;&lt;/span&gt;/dev/null
&lt;span class="nv"&gt;rc&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$?&lt;/span&gt;
&lt;span class="nb"&gt;set&lt;/span&gt; &lt;span class="nt"&gt;-e&lt;/span&gt;
&lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nv"&gt;$rc&lt;/span&gt; &lt;span class="k"&gt;in
  &lt;/span&gt;0&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"OK plan converged"&lt;/span&gt; &lt;span class="p"&gt;;;&lt;/span&gt;
  2&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"FAIL plan did not converge:"&lt;/span&gt;
     terraform show &lt;span class="nt"&gt;-json&lt;/span&gt; recheck.tfplan | jq &lt;span class="nt"&gt;-r&lt;/span&gt; &lt;span class="s1"&gt;'
       .resource_changes[]
       | select(.change.actions == ["update"])
       | .change as $c
       | .address + ": " + ([$c.after | keys[]
           | select($c.before[.] != $c.after[.] and ($c.after_unknown[.] // false) != true)]
           | join(", "))'&lt;/span&gt;
     &lt;span class="nv"&gt;fail&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;1 &lt;span class="p"&gt;;;&lt;/span&gt;
  &lt;span class="k"&gt;*&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"ERROR plan failed"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nv"&gt;fail&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;1 &lt;span class="p"&gt;;;&lt;/span&gt;
&lt;span class="k"&gt;esac&lt;/span&gt;
&lt;span class="nb"&gt;exit&lt;/span&gt; &lt;span class="nv"&gt;$fail&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Run as &lt;code&gt;./verify-gke.sh prod-autopilot us-central1 3888000s 259200s&lt;/code&gt;, a cluster hit by Case A or Case B fails on step 1, whatever the plan says. A private cluster hit by #2697 fails on step 3 and prints &lt;code&gt;module.gke.google_container_cluster.primary: master_authorized_networks_config&lt;/code&gt;, which names the culprit instead of dumping the whole plan. Compare duration strings in the form GKE returns them; if your config uses a different form, normalise before comparing.&lt;/p&gt;

&lt;p&gt;If you would rather keep the check in Terraform, a &lt;a href="https://developer.hashicorp.com/terraform/language/block/check" rel="noopener noreferrer"&gt;&lt;code&gt;check&lt;/code&gt; block&lt;/a&gt; works, as long as it reads the API directly with the &lt;code&gt;http&lt;/code&gt; data source and not through &lt;code&gt;google_container_cluster&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="k"&gt;data&lt;/span&gt; &lt;span class="s2"&gt;"google_client_config"&lt;/span&gt; &lt;span class="s2"&gt;"current"&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;

&lt;span class="nx"&gt;check&lt;/span&gt; &lt;span class="s2"&gt;"gke_disruption_budget"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="k"&gt;data&lt;/span&gt; &lt;span class="s2"&gt;"http"&lt;/span&gt; &lt;span class="s2"&gt;"cluster"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;url&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"https://container.googleapis.com/v1/projects/my-project/locations/us-central1/clusters/prod-autopilot"&lt;/span&gt;
    &lt;span class="nx"&gt;request_headers&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nx"&gt;Authorization&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"Bearer &lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="k"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;google_client_config&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;current&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;access_token&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;

  &lt;span class="nx"&gt;assert&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;condition&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;try&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
      &lt;span class="nx"&gt;jsondecode&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;cluster&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;response_body&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nx"&gt;maintenancePolicy&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;disruptionBudget&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;minorVersionDisruptionInterval&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="s2"&gt;"unset"&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"3888000s"&lt;/span&gt;
    &lt;span class="nx"&gt;error_message&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"Live cluster has no 45-day minor disruption budget. See hashicorp/terraform-provider-google#30554."&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The tradeoff is in how Terraform treats checks. A failed assertion, and even an error in the scoped data source, is reported as a warning and does not stop the plan or apply. That is good for visibility, because the warning sits in every PR plan where reviewers will see it. It is not a gate. Keep the script as the step that fails the pipeline, and use the &lt;code&gt;check&lt;/code&gt; block so humans see the problem in context.&lt;/p&gt;

&lt;p&gt;Around the gate, three habits close the remaining gaps:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Upgrade providers and modules on a copy first.&lt;/strong&gt; Apply to a non-production cluster, run the gate, and diff the &lt;code&gt;gcloud&lt;/code&gt; JSON before and after, not only the plan.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write down every exception.&lt;/strong&gt; Anything set outside Terraform, and every forked module, gets a comment in code and a ticket linked to the upstream issue, so it is removed once a fix ships.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Treat a recurring diff as an incident, not noise.&lt;/strong&gt; In the scenario, 90 meaningless pages a month is how the next real diff gets ignored.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Spotting the same class in other resources
&lt;/h2&gt;

&lt;p&gt;Neither bug is specific to GKE. When you adopt a new resource, a new block type or a new module, these are the questions we ask, roughly in order of how often they find something:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Does a second plan right after the first apply exit 0?&lt;/strong&gt; It is the cheapest test there is, and it catches every non-converging case.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Does the block have mutually exclusive variants?&lt;/strong&gt; Open the provider source and check that every shared sibling field appears in every branch of expand and flatten. A quick &lt;code&gt;grep -n&lt;/code&gt; for the sibling's API field name, counted against the number of branches, finds gaps like #30554 in minutes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Is the update a whole-object replace?&lt;/strong&gt; Look for &lt;code&gt;Set*Policy&lt;/code&gt;, &lt;code&gt;set*Config&lt;/code&gt; or a full PUT. If so, anything you set outside Terraform will be deleted by the next unrelated change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Can the config produce an empty nested block?&lt;/strong&gt; Check every &lt;code&gt;dynamic&lt;/code&gt; block whose &lt;code&gt;for_each&lt;/code&gt; depends on a flag that is not one of the block's own attributes, like &lt;code&gt;enable_private_endpoint&lt;/code&gt; here.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Is the block &lt;code&gt;Optional&lt;/code&gt; and &lt;code&gt;Computed&lt;/code&gt;?&lt;/strong&gt; If so, omitting it means Terraform does not own it. Decide whether that is what you want.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Was the field or variant added recently?&lt;/strong&gt; New branches have the least test coverage. &lt;code&gt;recurring_maintenance_window&lt;/code&gt; was about four months old when #30554 was filed. Read the expand and flatten of anything that new before you rely on it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Can you read the live value without going through the provider?&lt;/strong&gt; If not, you cannot verify the setting. Find a &lt;code&gt;gcloud&lt;/code&gt;, REST or &lt;code&gt;http&lt;/code&gt; path before you depend on it.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  How MigrateX handles this
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" alt="MigrateX" width="799" height="293"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;MigrateX is our platform and service for moving software, data and infrastructure from one technology to another. It combines automation with experienced engineers. The automation does the repetitive work quickly, and the engineers make the tricky decisions.&lt;/p&gt;

&lt;p&gt;Infrastructure moves are where bugs like these do the most damage. When you &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-compute-options" rel="noopener noreferrer"&gt;move EKS clusters to GKE&lt;/a&gt;, upgrade a major module version, or rewrite hand-built infrastructure in Terraform, hundreds of settings change at once. A plan that is quietly wrong, or one that is always noisy, is what lets a lost setting slip through. The gate above is the core of how MigrateX deals with it:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Record what the cluster really does.&lt;/strong&gt; Before we change anything, we capture each cluster's live settings from the cloud API: maintenance windows and budgets, endpoints, authorized networks, node pools and IAM. That is the baseline the new setup has to match, not the old Terraform code.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Check the round trip.&lt;/strong&gt; After each &lt;code&gt;apply&lt;/code&gt;, we read the live resources back through the API and compare them field by field with the baseline. A missing disruption budget shows up as a failed check, even when Terraform reports success.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Require a clean second plan.&lt;/strong&gt; Every workload must reach an empty plan before it moves on. A diff that never goes away, like the empty &lt;code&gt;master_authorized_networks_config&lt;/code&gt;, blocks the step until it is fixed or recorded as a known exception.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Track known issues.&lt;/strong&gt; When a provider or module bug affects a setting, we record the version, the workaround and the upstream issue. When the fix ships, we upgrade, remove the workaround and run the gate again.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Flag what needs a person.&lt;/strong&gt; Automation finds the mismatch. Our engineers decide whether it is a bug, an intended change or a gap in the baseline, and agree it with your team before the cluster carries traffic.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;What you get along the way:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No silent changes.&lt;/strong&gt; If a setting your cluster relies on goes missing, a check fails before production finds out.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plans you can trust again.&lt;/strong&gt; Clean plans mean real changes stand out in review.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Provider upgrades without surprises.&lt;/strong&gt; New versions are tested against the live baseline, not just the plan output.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A clear record.&lt;/strong&gt; Every workaround is tied to an upstream issue and removed once it is no longer needed.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;Running GKE with Terraform, or planning a move to it? See how &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;MigrateX&lt;/a&gt; works, or tell us a little about your setup through &lt;a href="https://cobuildx.ai/contact" rel="noopener noreferrer"&gt;Contact Us&lt;/a&gt;, and we'll start with a free chat about where the risks are likely to be.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;h3&gt;
  
  
  GitHub issues, pull requests and source
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;hashicorp/terraform-provider-google. &lt;em&gt;google_container_cluster: recurring_maintenance_window removes disruption_budget&lt;/em&gt; (#30554). &lt;a href="https://github.com/hashicorp/terraform-provider-google/issues/30554" rel="noopener noreferrer"&gt;https://github.com/hashicorp/terraform-provider-google/issues/30554&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;terraform-google-modules/terraform-google-kubernetes-engine. &lt;em&gt;master_authorized_networks_config {} rendered as an empty block when enable_private_endpoint = true, causing a permanent plan diff&lt;/em&gt; (#2697). &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/issues/2697" rel="noopener noreferrer"&gt;https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/issues/2697&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;terraform-google-modules/terraform-google-kubernetes-engine. &lt;em&gt;fix: allow enable_private_endpoint with no master_authorized_networks&lt;/em&gt; (#2058). &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/pull/2058" rel="noopener noreferrer"&gt;https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/pull/2058&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;terraform-google-modules/terraform-google-kubernetes-engine. &lt;em&gt;fix: skip master_authorized_networks_config when IP endpoints are disabled&lt;/em&gt; (#2687). &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/pull/2687" rel="noopener noreferrer"&gt;https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/pull/2687&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;terraform-google-modules/terraform-google-kubernetes-engine. &lt;em&gt;master_authorized_networks_config Drift with DNS Endpoints Enabled&lt;/em&gt; (#2460). &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/issues/2460" rel="noopener noreferrer"&gt;https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/issues/2460&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;GoogleCloudPlatform/magic-modules. &lt;em&gt;Add recurring maintenance window&lt;/em&gt; (#17899). &lt;a href="https://github.com/GoogleCloudPlatform/magic-modules/pull/17899" rel="noopener noreferrer"&gt;https://github.com/GoogleCloudPlatform/magic-modules/pull/17899&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;GoogleCloudPlatform/magic-modules. &lt;em&gt;resource_container_cluster.go.tmpl&lt;/em&gt;. &lt;a href="https://github.com/GoogleCloudPlatform/magic-modules/blob/main/mmv1/third_party/terraform/services/container/resource_container_cluster.go.tmpl" rel="noopener noreferrer"&gt;https://github.com/GoogleCloudPlatform/magic-modules/blob/main/mmv1/third_party/terraform/services/container/resource_container_cluster.go.tmpl&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;terraform-google-modules/terraform-google-kubernetes-engine. &lt;em&gt;autogen/main/cluster.tf.tmpl&lt;/em&gt;. &lt;a href="https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/blob/main/autogen/main/cluster.tf.tmpl" rel="noopener noreferrer"&gt;https://github.com/terraform-google-modules/terraform-google-kubernetes-engine/blob/main/autogen/main/cluster.tf.tmpl&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Google Cloud and Terraform
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Maintenance windows and exclusions&lt;/em&gt;. &lt;a href="https://cloud.google.com/kubernetes-engine/docs/concepts/maintenance-windows-and-exclusions" rel="noopener noreferrer"&gt;https://cloud.google.com/kubernetes-engine/docs/concepts/maintenance-windows-and-exclusions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Configure maintenance windows and exclusions&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/how-to/maintenance-windows-and-exclusions" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/kubernetes-engine/docs/how-to/maintenance-windows-and-exclusions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Configure a cluster disruption budget&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/how-to/cluster-disruption-budget" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/kubernetes-engine/docs/how-to/cluster-disruption-budget&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Add authorized networks for control plane access&lt;/em&gt;. &lt;a href="https://cloud.google.com/kubernetes-engine/docs/how-to/authorized-networks" rel="noopener noreferrer"&gt;https://cloud.google.com/kubernetes-engine/docs/how-to/authorized-networks&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;HashiCorp. &lt;em&gt;Command: plan&lt;/em&gt; (&lt;code&gt;-detailed-exitcode&lt;/code&gt;). &lt;a href="https://developer.hashicorp.com/terraform/cli/commands/plan" rel="noopener noreferrer"&gt;https://developer.hashicorp.com/terraform/cli/commands/plan&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;HashiCorp. &lt;em&gt;check block reference&lt;/em&gt;. &lt;a href="https://developer.hashicorp.com/terraform/language/block/check" rel="noopener noreferrer"&gt;https://developer.hashicorp.com/terraform/language/block/check&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;HashiCorp. &lt;em&gt;CLI configuration: development overrides for provider developers&lt;/em&gt;. &lt;a href="https://developer.hashicorp.com/terraform/cli/config/config-file#development-overrides-for-provider-developers" rel="noopener noreferrer"&gt;https://developer.hashicorp.com/terraform/cli/config/config-file#development-overrides-for-provider-developers&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;HashiCorp. &lt;em&gt;http data source&lt;/em&gt;. &lt;a href="https://registry.terraform.io/providers/hashicorp/http/latest/docs/data-sources/http" rel="noopener noreferrer"&gt;https://registry.terraform.io/providers/hashicorp/http/latest/docs/data-sources/http&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;CobuildX helps teams migrate legacy applications and cloud infrastructure with &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;MigrateX&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/gke-terraform-silent-drift" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>terraform</category>
      <category>googlecloud</category>
      <category>kubernetes</category>
      <category>devops</category>
    </item>
    <item>
      <title>Moving Storage from AWS to GCP: S3, Disks and File Shares</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Thu, 05 Nov 2026 09:22:58 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/moving-storage-from-aws-to-gcp-s3-disks-and-file-shares-8h3</link>
      <guid>https://dev.to/cobuildx-ai/moving-storage-from-aws-to-gcp-s3-disks-and-file-shares-8h3</guid>
      <description>&lt;p&gt;&lt;em&gt;A worked AWS to Google Cloud storage migration: 400 TB of S3 with 2 billion small objects and a Deep Archive tier, a Postgres on EBS and an EFS share. Egress and per-object cost math, Storage Transfer Service tradeoffs, storage class traps, checksum verification, and a delta-sync cutover that fits a 30-minute freeze.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;You have 400 TB in S3 across four buckets, two billion of those objects are thumbnails under 20 KB, 90 TB sits in Glacier Deep Archive for compliance, a Postgres primary lives on gp3 volumes, and twelve render workers share an EFS mount. The GCP contract is signed. The first instinct is to start &lt;code&gt;gcloud storage rsync&lt;/code&gt; on a big VM and wait.&lt;/p&gt;

&lt;p&gt;That instinct gets the order wrong. Terabytes decide how long the bytes take to move, but they don't decide the plan. The object count decides the bill and the timeline. The archive tier decides what you must do on AWS before any copy can start. The cutover window decides how you handle deletes. This post works through one representative workload end to end and makes each of those decisions with numbers.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;This guide covers storage.&lt;/strong&gt; For EC2, EKS and GPUs, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-compute-options" rel="noopener noreferrer"&gt;moving compute from AWS to GCP&lt;/a&gt;. For Lambda, Fargate and EventBridge, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-serverless" rel="noopener noreferrer"&gt;moving serverless from AWS to GCP&lt;/a&gt;. For Redshift, EMR and Glue, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-big-data" rel="noopener noreferrer"&gt;moving big data from AWS to GCP&lt;/a&gt;. Going the other way? Read &lt;a href="https://cobuildx.ai/blog/gcp-to-aws-storage" rel="noopener noreferrer"&gt;moving storage from GCP to AWS&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  The workload we'll move
&lt;/h2&gt;

&lt;p&gt;This is an illustrative workload, not a customer. The shape is common for a media-heavy SaaS product: a few large buckets, one bucket with an enormous object count, a cold archive, a database and a shared file system. Source is &lt;code&gt;us-east-1&lt;/code&gt;, target is &lt;code&gt;us-central1&lt;/code&gt;. All prices below are list prices as of November 2026 for those two regions.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Dataset&lt;/th&gt;
&lt;th&gt;AWS today&lt;/th&gt;
&lt;th&gt;Size&lt;/th&gt;
&lt;th&gt;Objects&lt;/th&gt;
&lt;th&gt;Notes&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;media-originals&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;S3 Standard&lt;/td&gt;
&lt;td&gt;150 TB&lt;/td&gt;
&lt;td&gt;40 M (avg 3.75 MB)&lt;/td&gt;
&lt;td&gt;Read and written by the app; many objects uploaded with multipart&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;thumbs&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;S3 Standard&lt;/td&gt;
&lt;td&gt;30 TB&lt;/td&gt;
&lt;td&gt;2.0 B (avg 15 KB)&lt;/td&gt;
&lt;td&gt;Served through a CDN; keys are &lt;code&gt;thumbs/{userId}/{photoId}_{size}.webp&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;exports&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;S3 Standard-IA&lt;/td&gt;
&lt;td&gt;130 TB&lt;/td&gt;
&lt;td&gt;6 M (avg 22 MB)&lt;/td&gt;
&lt;td&gt;Customer exports and backups; lifecycle deletes them at 400 days&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;audit-archive&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;S3 Glacier Deep Archive&lt;/td&gt;
&lt;td&gt;90 TB&lt;/td&gt;
&lt;td&gt;9 M (avg 10 MB)&lt;/td&gt;
&lt;td&gt;Seven-year compliance retention; read maybe once a year&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Postgres&lt;/td&gt;
&lt;td&gt;EBS gp3, primary and replica&lt;/td&gt;
&lt;td&gt;2 x 6 TB volumes, 3.5 TB of data&lt;/td&gt;
&lt;td&gt;n/a&lt;/td&gt;
&lt;td&gt;12,000 IOPS and 500 MiB/s provisioned per volume&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Render share&lt;/td&gt;
&lt;td&gt;Amazon EFS&lt;/td&gt;
&lt;td&gt;12 TB&lt;/td&gt;
&lt;td&gt;Tens of millions of files&lt;/td&gt;
&lt;td&gt;NFS mount on 12 workers&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Constraints: four platform engineers, and the business accepts one write freeze of at most 30 minutes per application. Everything else has to happen while production runs.&lt;/p&gt;

&lt;p&gt;The target services are not the hard part. They map closely, and the figure below is the whole mapping. The rest of this post is about the decisions the mapping doesn't make for you.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feiek43d022xxg8ifzy6f.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feiek43d022xxg8ifzy6f.png" alt="Storage service map from AWS to Google Cloud: Amazon S3 to Cloud Storage, EBS to Persistent Disk or Hyperdisk, EFS to Filestore, FSx for NetApp ONTAP to Google Cloud NetApp Volumes, FSx for Windows to NetApp Volumes SMB, and AWS Backup to Backup and DR Service, with what to watch for on each" width="800" height="462"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Smaller pieces map simply: instance store becomes Local SSD, FSx for Lustre becomes Managed Lustre, and the &lt;code&gt;aws s3&lt;/code&gt; command line becomes &lt;code&gt;gcloud storage&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuor9lylvln4drljhdlrr.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuor9lylvln4drljhdlrr.png" alt="Storage decision flow, one dataset at a time: if it is files in a bucket, use Cloud Storage with Autoclass or a class chosen by read frequency; if it is a disk for one machine, use Hyperdisk or Persistent Disk, whichever the machine series takes; if Linux machines share a folder, use Filestore sized from real usage; if it needs SMB or NetApp features, use NetApp Volumes with NFS, SMB and Active Directory; backups go to Backup and DR Service with locked vaults in a separate project. Stop at the first yes" width="800" height="421"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the money goes
&lt;/h2&gt;

&lt;p&gt;Most migration budgets start and stop at egress. For this workload, egress is the line you can most easily make zero, and the line nobody budgets for is per-object operations.&lt;/p&gt;

&lt;h3&gt;
  
  
  Egress: three ways to pay for 400 TB
&lt;/h3&gt;

&lt;p&gt;AWS charges for data transfer out to the internet in &lt;code&gt;us-east-1&lt;/code&gt; at $0.09 per GB for the first 10 TB in a month, $0.085 for the next 40 TB, $0.07 for the next 100 TB and $0.05 beyond 150 TB, after a free 100 GB per month [19][20]. If all 400 TB leaves in one billing month, that's about $23,800. Spread the same copy over two months and the tiers reset, which pushes it to about $27,600.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Path&lt;/th&gt;
&lt;th&gt;Cost for 400 TB&lt;/th&gt;
&lt;th&gt;What it costs you instead&lt;/th&gt;
&lt;th&gt;Pick it when&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Storage Transfer Service over the public internet, with the AWS exit credit&lt;/td&gt;
&lt;td&gt;$0 egress after the credit&lt;/td&gt;
&lt;td&gt;Eligibility rules and a deadline to finish&lt;/td&gt;
&lt;td&gt;You are moving all your data off AWS, or all data for a service such as S3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Storage Transfer Service over the Google-managed private network&lt;/td&gt;
&lt;td&gt;$0.03 per GiB in North America, about $11,200; no AWS internet egress&lt;/td&gt;
&lt;td&gt;Shared pooled bandwidth that can throttle at peak; console or REST API only&lt;/td&gt;
&lt;td&gt;You don't qualify for the credit, for example you keep some S3 data on AWS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Storage Transfer Service over the public internet, no credit&lt;/td&gt;
&lt;td&gt;About $23,800 to $27,600&lt;/td&gt;
&lt;td&gt;Nothing else, but it's the most expensive&lt;/td&gt;
&lt;td&gt;Small partial moves where neither of the above applies&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The exit credit is the cheapest path, and its terms are what shape the rest of the plan. AWS waives data transfer out to the internet for eligible customers moving off AWS. You request it through AWS Support before the copy starts. AWS's announcement post says the waiver applies when you move all your data from all eligible accounts, or all your data for a particular service across those accounts. It currently gives customers outside the EU 180 days to finish, after earlier versions said 60 and then 90, so get the window confirmed in writing for your account. EU and UK customers follow the AWS EU Data Act and UK switching addenda instead [18].&lt;/p&gt;

&lt;p&gt;The Google-managed private network option is the fallback. Storage Transfer Service routes the copy over private links that Google provisions, and you pay no S3 internet egress. You do pay a Google-side fee per GiB, plus the normal S3 request charges. It only works for agentless S3 transfers from listed AWS regions (&lt;code&gt;us-east-1&lt;/code&gt; is one), and it can't be configured from &lt;code&gt;gcloud&lt;/code&gt; or the client libraries [3][4].&lt;/p&gt;

&lt;h3&gt;
  
  
  Operations: the two billion objects
&lt;/h3&gt;

&lt;p&gt;Every object Storage Transfer Service writes is at least one Class A operation on Cloud Storage. In a regional bucket, Class A costs $0.005 per 1,000 operations in Standard, $0.01 in Nearline, $0.02 in Coldline and $0.05 in Archive [1]. Run the thumbnails through that:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Landing class for &lt;code&gt;thumbs&lt;/code&gt;
&lt;/th&gt;
&lt;th&gt;Class A writes for 2.0 B objects&lt;/th&gt;
&lt;th&gt;Cost per TB moved&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Standard&lt;/td&gt;
&lt;td&gt;$10,000&lt;/td&gt;
&lt;td&gt;About $333&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Nearline&lt;/td&gt;
&lt;td&gt;$20,000&lt;/td&gt;
&lt;td&gt;About $667&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Coldline&lt;/td&gt;
&lt;td&gt;$40,000&lt;/td&gt;
&lt;td&gt;About $1,333&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Archive&lt;/td&gt;
&lt;td&gt;$100,000&lt;/td&gt;
&lt;td&gt;About $3,333&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Compare that with &lt;code&gt;media-originals&lt;/code&gt;: 150 TB in 40 million objects costs $200 to write in Standard, about $1.33 per TB. The thumbnails are 7.5% of the bytes and 93% of the Cloud Storage write bill. On the AWS side the same objects are cheap to read: GET requests cost $0.0004 per 1,000, so two billion GETs are about $800, and the two million LIST pages needed to enumerate them are about $10 [19].&lt;/p&gt;

&lt;p&gt;That table also kills a tempting idea. A team that wants to save on storage might land cold thumbnails straight into Coldline or Archive. The write bill alone would be four to ten times the Standard figure, before the minimum storage durations even start.&lt;/p&gt;

&lt;p&gt;The real alternative is not copying them. Regenerating every thumbnail on GCP from the originals still writes two billion objects, so it saves nothing. Regenerating them lazily, on the first request after cutover, writes only the thumbnails people actually look at. If 20% get requested in the first quarter, that's 400 million writes, about $2,000. The cost is a cache-miss storm on launch day and a thumbnail service that must already run on GCP before cutover.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Our call for this workload:&lt;/strong&gt; copy the thumbnails. $10,000 is less than the engineering time to make lazy generation safe under launch-day traffic. The decision flips if the object count were ten times larger, or if the thumbnail service already handles misses gracefully and access is concentrated on recent uploads.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h3&gt;
  
  
  The archive: restore before you can copy
&lt;/h3&gt;

&lt;p&gt;Storage Transfer Service cannot read objects that are still archived. It skips S3 Glacier Flexible Retrieval objects by default, and it transfers Deep Archive objects only after they have been restored [3]. A job pointed at &lt;code&gt;audit-archive&lt;/code&gt; without a restore will finish quickly, report success, and copy close to nothing. Log skipped objects (&lt;code&gt;--log-action-states=failed,skipped&lt;/code&gt;) and check the counts.&lt;/p&gt;

&lt;p&gt;There are two honest options for the 90 TB.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Option&lt;/th&gt;
&lt;th&gt;One-time cost&lt;/th&gt;
&lt;th&gt;Ongoing cost&lt;/th&gt;
&lt;th&gt;What it really costs you&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Leave it in Deep Archive until retention ends&lt;/td&gt;
&lt;td&gt;$0&lt;/td&gt;
&lt;td&gt;About $89 per month at $0.00099 per GB-month&lt;/td&gt;
&lt;td&gt;An AWS account, IAM and billing kept alive for years, and S3 no longer fully moved, which can cost you the exit credit on the other 310 TB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Restore with Bulk retrieval and copy into Archive class&lt;/td&gt;
&lt;td&gt;About $225 retrieval ($0.0025 per GB), about $9 of Batch Operations, about $450 of Archive Class A writes&lt;/td&gt;
&lt;td&gt;About $108 per month at Archive list price&lt;/td&gt;
&lt;td&gt;Up to 48 hours per restore wave, plus paying for the temporary restored copies while they exist&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;We'd restore and copy. The archive costs about $700 to move, and leaving it behind puts a five-figure egress credit at risk. The decision flips if retention ends within a year and you're keeping other workloads on AWS anyway.&lt;/p&gt;

&lt;p&gt;Mechanics matter here. Deep Archive Bulk restores typically finish within 48 hours, and S3 accepts restore requests at 1,000 per second per account, so 9 million individual &lt;code&gt;RestoreObject&lt;/code&gt; calls from a script will throttle. S3 Batch Operations, driven by an S3 Inventory manifest, uses the full request rate for you [21][22]. Restored copies exist for the number of days you set, and you pay for them on top of the archived object [23]. Restore in waves by prefix, with &lt;code&gt;ExpirationInDays&lt;/code&gt; set just long enough for the copy to finish.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Restore one wave of audit-archive with Bulk retrieval, driven by an S3 Inventory manifest&lt;/span&gt;
aws s3control create-job &lt;span class="nt"&gt;--account-id&lt;/span&gt; 111122223333 &lt;span class="nt"&gt;--region&lt;/span&gt; us-east-1 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--operation&lt;/span&gt; &lt;span class="s1"&gt;'{"S3InitiateRestoreObject":{"ExpirationInDays":7,"GlacierJobTier":"BULK"}}'&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--manifest&lt;/span&gt; &lt;span class="s1"&gt;'{"Spec":{"Format":"S3InventoryReport_CSV_20161130"},
               "Location":{"ObjectArn":"arn:aws:s3:::acme-inventory/audit-archive/2026-11-01/manifest.json",
                           "ETag":"&amp;lt;manifest-etag&amp;gt;"}}'&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--report&lt;/span&gt; &lt;span class="s1"&gt;'{"Enabled":true,"Bucket":"arn:aws:s3:::acme-inventory","Prefix":"restore-reports",
             "Format":"Report_CSV_20180820","ReportScope":"FailedTasksOnly"}'&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--priority&lt;/span&gt; 10 &lt;span class="nt"&gt;--no-confirmation-required&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--role-arn&lt;/span&gt; arn:aws:iam::111122223333:role/batch-restore
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;One more AWS-side charge: reading Standard-IA data costs $0.01 per GB, so copying the 130 TB &lt;code&gt;exports&lt;/code&gt; bucket adds about $1,300 in retrieval fees [19].&lt;/p&gt;

&lt;h2&gt;
  
  
  Choosing the copy tool
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsvgwg2hvcpc8t8kmhdug.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsvgwg2hvcpc8t8kmhdug.png" alt="How the data moves: S3 buckets are copied to Cloud Storage by Storage Transfer Service with no agent; event-driven transfers keep them in sync through S3 notifications on SQS; EFS and FSx shares are copied by Storage Transfer Service agents or NetApp SnapMirror; disks move with their VMs through Migrate to Virtual Machines; a final sync runs before the switch" width="799" height="271"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Cost&lt;/th&gt;
&lt;th&gt;Good at&lt;/th&gt;
&lt;th&gt;Reject it when&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Storage Transfer Service, agentless&lt;/td&gt;
&lt;td&gt;No service fee for agentless transfers; you pay operations and egress&lt;/td&gt;
&lt;td&gt;Managed retries, checksum validation, skip-if-unchanged, logs, event-driven sync&lt;/td&gt;
&lt;td&gt;You need to transform objects in flight&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;gcloud storage rsync&lt;/code&gt; or rclone on VMs&lt;/td&gt;
&lt;td&gt;VMs and your time&lt;/td&gt;
&lt;td&gt;Small buckets, ad-hoc fixes, renaming or repacking during the copy&lt;/td&gt;
&lt;td&gt;Billions of objects: you now own retries, parallelism, checksums and restarts&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Transfer Appliance&lt;/td&gt;
&lt;td&gt;Appliance fees and shipping&lt;/td&gt;
&lt;td&gt;Data in your own data centre with a thin network link&lt;/td&gt;
&lt;td&gt;The data is already in AWS: there's no way to plug it into an AWS region, so it doesn't apply&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cloud Storage XML API with HMAC keys&lt;/td&gt;
&lt;td&gt;Free to set up&lt;/td&gt;
&lt;td&gt;Pointing existing S3 tools at &lt;code&gt;storage.googleapis.com&lt;/code&gt; during the move&lt;/td&gt;
&lt;td&gt;As the end state: some S3 features and SDK defaults don't carry over&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Storage Transfer Service is the default for all four buckets [2][4]. Read access on AWS should be a federated IAM role, not a long-lived access key:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# aws-role.json: {"role_arn": "arn:aws:iam::111122223333:role/gcs-transfer-reader"}&lt;/span&gt;

&lt;span class="c"&gt;# Bulk copy of the originals, skipping anything still archived&lt;/span&gt;
gcloud transfer &lt;span class="nb"&gt;jobs &lt;/span&gt;create s3://acme-media-originals gs://acme-media-originals &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--source-creds-file&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;aws-role.json &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--include-storage-classes&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;STANDARD &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--custom-storage-class&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;STANDARD &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--overwrite-when&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;different &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--log-actions&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;copy,find &lt;span class="nt"&gt;--log-action-states&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;failed,skipped

&lt;span class="c"&gt;# Exports land directly in Nearline (see the class section for why)&lt;/span&gt;
gcloud transfer &lt;span class="nb"&gt;jobs &lt;/span&gt;create s3://acme-exports gs://acme-exports &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--source-creds-file&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;aws-role.json &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--custom-storage-class&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;NEARLINE &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--overwrite-when&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;different
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  How long it takes: bytes versus objects
&lt;/h3&gt;

&lt;p&gt;Bytes first. If the transfer sustains 10 Gbps in aggregate, that's about 4.5 TB per hour, so 400 TB is about 3.7 days of pure byte movement. Treat 10 Gbps as an assumption to test in the pilot, not a promise.&lt;/p&gt;

&lt;p&gt;Objects second, and for &lt;code&gt;thumbs&lt;/code&gt; this is the number that matters. Cloud Storage starts each bucket at roughly 1,000 object writes per second. It scales up automatically, but Google's guidance is to grow load no faster than doubling every 20 minutes, and sequential key names slow that scaling down. With a random prefix, a bucket can reach roughly 16,000 writes per second [5].&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Sustained write rate into &lt;code&gt;thumbs&lt;/code&gt;
&lt;/th&gt;
&lt;th&gt;Time for 2.0 B objects&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1,000 objects/s (a new bucket, no ramp)&lt;/td&gt;
&lt;td&gt;About 23 days&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5,000 objects/s&lt;/td&gt;
&lt;td&gt;About 4.6 days&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;16,000 objects/s (well-spread keys, fully ramped)&lt;/td&gt;
&lt;td&gt;About 35 hours&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These are Cloud Storage ceilings, not Storage Transfer Service guarantees. Google doesn't publish an object rate for the service, so measure it. Run the pilot on a single &lt;code&gt;thumbs/{userId}/&lt;/code&gt; range, read the objects-copied rate from the job, and multiply. Our keys start with a user ID, which spreads writes better than a timestamp prefix would. If your keys start with dates, split the job by prefix and run the parts in parallel so the writes land across the key range.&lt;/p&gt;

&lt;p&gt;The practical result: bytes for the big buckets finish in days, and the thumbnail bucket sets the critical path. Start it first.&lt;/p&gt;

&lt;h2&gt;
  
  
  Storage classes: map by access, not by name
&lt;/h2&gt;

&lt;p&gt;The class table is short. The traps are in what Storage Transfer Service doesn't carry over.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;S3 class&lt;/th&gt;
&lt;th&gt;Cloud Storage class&lt;/th&gt;
&lt;th&gt;Minimum storage duration (S3 vs GCS)&lt;/th&gt;
&lt;th&gt;Read latency on GCS&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;S3 Standard&lt;/td&gt;
&lt;td&gt;Standard&lt;/td&gt;
&lt;td&gt;None vs none&lt;/td&gt;
&lt;td&gt;Milliseconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;S3 Standard-IA / One Zone-IA&lt;/td&gt;
&lt;td&gt;Nearline&lt;/td&gt;
&lt;td&gt;30 days vs 30 days&lt;/td&gt;
&lt;td&gt;Milliseconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;S3 Glacier Instant Retrieval&lt;/td&gt;
&lt;td&gt;Coldline&lt;/td&gt;
&lt;td&gt;90 days vs 90 days&lt;/td&gt;
&lt;td&gt;Milliseconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;S3 Glacier Flexible Retrieval&lt;/td&gt;
&lt;td&gt;Coldline or Archive&lt;/td&gt;
&lt;td&gt;90 days vs 90 or 365 days&lt;/td&gt;
&lt;td&gt;Milliseconds, no restore step&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;S3 Glacier Deep Archive&lt;/td&gt;
&lt;td&gt;Archive&lt;/td&gt;
&lt;td&gt;180 days vs 365 days&lt;/td&gt;
&lt;td&gt;Milliseconds, no restore step&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;S3 Intelligent-Tiering&lt;/td&gt;
&lt;td&gt;Autoclass&lt;/td&gt;
&lt;td&gt;None vs none&lt;/td&gt;
&lt;td&gt;Milliseconds&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Every Cloud Storage class reads in milliseconds, including Archive. There is no restore step. And there's no 128 KB minimum billable object size like S3 Standard-IA and Glacier Instant Retrieval have [1][24].&lt;/p&gt;

&lt;h3&gt;
  
  
  Trap 1: lifecycle ages restart on migration day
&lt;/h3&gt;

&lt;p&gt;Storage Transfer Service keeps Content-Type, user metadata and the source ETag. It doesn't keep the S3 last-modified timestamp, ACLs or object tags [6]. Every migrated object is born on the day it was copied. An &lt;code&gt;age&lt;/code&gt; condition in a lifecycle rule counts from that birth.&lt;/p&gt;

&lt;p&gt;For &lt;code&gt;exports&lt;/code&gt;, that bites twice. If you land the bucket in Standard and rely on an &lt;code&gt;age = 30&lt;/code&gt; rule to move it to Nearline, you pay Standard for 30 days on 130 TB: about $1,300 more than landing it in Nearline directly. And the S3 rule that deletes exports at 400 days stops firing: objects that were 399 days old on AWS live another 400 days on GCP.&lt;/p&gt;

&lt;p&gt;The fix is cheap for 6 million objects. Write the S3 last-modified time from the inventory into each object's &lt;code&gt;customTime&lt;/code&gt; after the copy, and base lifecycle on &lt;code&gt;days_since_custom_time&lt;/code&gt;. At Nearline Class A rates, 6 million metadata updates cost about $60. Don't do the same for &lt;code&gt;thumbs&lt;/code&gt;: two billion updates would be another $10,000. Skip objects that are within 30 days of their deletion date entirely, because a Nearline object deleted early is still billed for 30 days.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_storage_bucket"&lt;/span&gt; &lt;span class="s2"&gt;"exports"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;                        &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"acme-exports"&lt;/span&gt;
  &lt;span class="nx"&gt;location&lt;/span&gt;                    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"US-CENTRAL1"&lt;/span&gt;
  &lt;span class="nx"&gt;storage_class&lt;/span&gt;               &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"NEARLINE"&lt;/span&gt;
  &lt;span class="nx"&gt;uniform_bucket_level_access&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
  &lt;span class="nx"&gt;public_access_prevention&lt;/span&gt;    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"enforced"&lt;/span&gt;

  &lt;span class="c1"&gt;# customTime carries the original S3 LastModified, so retention survives the move&lt;/span&gt;
  &lt;span class="nx"&gt;lifecycle_rule&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;condition&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;days_since_custom_time&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;400&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="nx"&gt;action&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"Delete"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Trap 2: early deletion during the migration itself
&lt;/h3&gt;

&lt;p&gt;Cloud Storage charges early deletion when an object in Nearline, Coldline or Archive is deleted, replaced or rewritten before its minimum duration. A rewrite to change storage class counts. A lifecycle class change doesn't, and Autoclass buckets never pay early deletion [1]. The migration risk is a second full run with &lt;code&gt;--overwrite-when=always&lt;/code&gt; into a Nearline bucket, which pays 30 days of early deletion on everything it overwrites. Keep &lt;code&gt;--overwrite-when=different&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Soft delete is on by default with a 7-day window, and time as a soft-deleted object counts toward the minimum. If a botched first run of &lt;code&gt;thumbs&lt;/code&gt; has to be deleted and redone, the deleted copies stay billable for a week. Run the pilot before the full job, not after.&lt;/p&gt;

&lt;h3&gt;
  
  
  Trap 3: Autoclass ignores small objects
&lt;/h3&gt;

&lt;p&gt;Autoclass charges a management fee of $0.0025 per 1,000 objects per month, but objects smaller than 128 KiB are not managed and not counted [1]. For &lt;code&gt;media-originals&lt;/code&gt;, that's 40 million objects and about $100 a month, a fair price for unknown access patterns. For &lt;code&gt;thumbs&lt;/code&gt;, Autoclass would do nothing: every thumbnail stays in Standard. Decide the class for small-object buckets yourself.&lt;/p&gt;

&lt;h2&gt;
  
  
  Access and events
&lt;/h2&gt;

&lt;p&gt;Bucket policies don't convert line by line. Turn on uniform bucket-level access, keep public access prevention enforced, and rewrite each policy from what each principal actually does. A prefix-scoped S3 grant becomes an IAM binding with a condition:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# Before: S3 bucket policy statement
{ "Effect": "Allow",
  "Principal": { "AWS": "arn:aws:iam::111122223333:role/thumb-renderer" },
  "Action": "s3:GetObject",
  "Resource": "arn:aws:s3:::acme-thumbs/thumbs/*" }

# After: uniform access plus a conditional IAM binding
gcloud storage buckets update gs://acme-thumbs \
  --uniform-bucket-level-access --public-access-prevention
gcloud storage buckets add-iam-policy-binding gs://acme-thumbs \
  --member=serviceAccount:thumb-renderer@acme-prod.iam.gserviceaccount.com \
  --role=roles/storage.objectViewer \
  --condition='expression=resource.name.startsWith("projects/_/buckets/acme-thumbs/objects/thumbs/"),title=thumbs-only'
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Explicit &lt;code&gt;Deny&lt;/code&gt; statements keyed on &lt;code&gt;aws:SourceVpce&lt;/code&gt; or source IP have no direct bucket-level equivalent. That intent usually moves to a VPC Service Controls perimeter around the project. Public website assets go behind Cloud CDN and a load balancer, not a public bucket.&lt;/p&gt;

&lt;p&gt;Events have two gotchas, one on each side.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;On AWS, adding the sync queue can fail.&lt;/strong&gt; Event-driven transfers need S3 to send object-create events to an SQS queue [7]. If the bucket already sends &lt;code&gt;s3:ObjectCreated:*&lt;/code&gt; for the whole bucket to a Lambda, S3 rejects a second configuration with an overlapping prefix for the same event type [25]. Fanning out through an SNS topic with raw message delivery is the usual workaround. Test it on the pilot bucket, because Google documents only direct S3-to-SQS delivery.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;On GCP, don't create notifications before the bulk copy.&lt;/strong&gt; A Pub/Sub &lt;code&gt;OBJECT_FINALIZE&lt;/code&gt; notification on &lt;code&gt;thumbs&lt;/code&gt; during the load fires two billion messages, and any subscriber, like a thumbnail generator or a search indexer, processes the whole history again. Create notifications as a cutover step, after the bulk copy is done.
&lt;/li&gt;
&lt;/ul&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Cutover step, not setup step&lt;/span&gt;
gcloud storage buckets notifications create gs://acme-media-originals &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--topic&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;media-object-events &lt;span class="nt"&gt;--event-types&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;OBJECT_FINALIZE,OBJECT_DELETE
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  The database on EBS: don't copy the disk
&lt;/h2&gt;

&lt;p&gt;Disks for ordinary VMs move with their machines through Migrate to Virtual Machines, which replicates EBS volumes while the instance runs (the compute post covers this). A database is different, because what you want at cutover is a consistent database, not a consistent block device.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Option&lt;/th&gt;
&lt;th&gt;Cutover downtime&lt;/th&gt;
&lt;th&gt;What it costs you&lt;/th&gt;
&lt;th&gt;Pick it when&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Block replication of the EBS volumes&lt;/td&gt;
&lt;td&gt;Stop Postgres, final sync, boot on GCP&lt;/td&gt;
&lt;td&gt;A cold start on the new disk, and the outage includes the last sync&lt;/td&gt;
&lt;td&gt;The database is small or downtime is cheap&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Streaming replica on Compute Engine over HA VPN, then promote&lt;/td&gt;
&lt;td&gt;Seconds to drain lag, then promote&lt;/td&gt;
&lt;td&gt;You run the VPN, the replica build and the promotion runbook&lt;/td&gt;
&lt;td&gt;You stay on self-managed Postgres&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Database Migration Service to Cloud SQL or AlloyDB&lt;/td&gt;
&lt;td&gt;Similar to a replica promotion&lt;/td&gt;
&lt;td&gt;A managed target with its own limits on extensions and settings&lt;/td&gt;
&lt;td&gt;You want to stop running Postgres yourself&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;For 3.5 TB, the initial copy is not the hard part. At an effective 1 Gbps over the VPN, 3.5 TB takes about 7.8 hours, and the primary keeps serving the whole time. What matters is that a replica turns the cutover into a lag check plus a promotion, which fits a 30-minute freeze with room to spare. We'd reject block replication here: it puts a full database stop inside the window.&lt;/p&gt;

&lt;p&gt;Size the new disk from measurements, not from the gp3 settings. Pull the peak per-minute &lt;code&gt;VolumeReadOps&lt;/code&gt; and &lt;code&gt;VolumeWriteOps&lt;/code&gt; from CloudWatch over a busy month. Hyperdisk Balanced lets you provision IOPS and throughput separately from size, like gp3, so a 6 TB disk at 12,000 IOPS and 500 MiB/s maps directly [9]. Persistent Disk ties performance to size, so a small, fast gp3 volume can come out slower on &lt;code&gt;pd-balanced&lt;/code&gt; unless you make it bigger. Newer machine series such as N4, C4 and C4A only take Hyperdisk, so pick the machine first.&lt;/p&gt;

&lt;p&gt;One GCP option has no EBS match: Regional Persistent Disk and Hyperdisk Balanced High Availability keep a synchronous copy in two zones. It doesn't replace the Postgres replica, but it can replace snapshot-based zone recovery.&lt;/p&gt;

&lt;h2&gt;
  
  
  The EFS share: 12 TB of NFS
&lt;/h2&gt;

&lt;p&gt;Filestore is the usual target for EFS, and the billing model changes. EFS bills for the bytes you store. Filestore bills for the capacity you provision, full or not [10]. With 12 TB used and 30% headroom, you pay for about 16 TB from day one. Zonal and Regional tiers can grow later, so start close to real usage and set an alert on free space.&lt;/p&gt;

&lt;p&gt;The copy runs through Storage Transfer Service agents on EC2 instances that mount EFS. Agent-based file system transfers cost $0.0125 per GiB, about $140 for 12 TB [4]. Like S3, run a full pass while the workers keep writing, then incremental passes that move only changed files, then a final pass inside the freeze. For tens of millions of small files, the incremental pass is dominated by scanning, not copying. Time it in the pilot.&lt;/p&gt;

&lt;p&gt;Other file systems: FSx for NetApp ONTAP moves to Google Cloud NetApp Volumes with SnapMirror, which keeps NetApp snapshots and clones. FSx for Windows File Server usually becomes NetApp Volumes SMB shares joined to Active Directory, since Filestore is NFS only. FSx for Lustre becomes Managed Lustre.&lt;/p&gt;

&lt;h2&gt;
  
  
  Proving the copy: checksums that actually compare
&lt;/h2&gt;

&lt;p&gt;"The job succeeded" is not proof. Comparing hashes across clouds is harder than it looks, because the two sides don't store the same hash.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;S3 ETags are MD5 only sometimes.&lt;/strong&gt; For single PUT uploads with SSE-S3 or no encryption, the ETag is the MD5 of the data. For SSE-KMS or SSE-C, it isn't. For multipart uploads, it never is, regardless of encryption [26]. &lt;code&gt;media-originals&lt;/code&gt; is full of multipart uploads.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cloud Storage stores CRC32C on every object, and MD5 only on non-composite objects.&lt;/strong&gt; Google recommends CRC32C for integrity checks [11].&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Storage Transfer Service checks every object.&lt;/strong&gt; It uses source checksums where S3 provides them. For multipart and SSE-KMS objects, it computes a checksum on the fly and fails the task with &lt;code&gt;DATA_LOSS&lt;/code&gt; on a mismatch [8]. It also stores the source ETag on each object as &lt;code&gt;x-goog-source-etag&lt;/code&gt; [6].&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That last point gives you a cheap, independent check. S3 Inventory lists key, size and ETag for $0.0025 per million objects, about $5 for all of &lt;code&gt;thumbs&lt;/code&gt; [19]. Load it and a listing of the Cloud Storage bucket into BigQuery and diff them:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="c1"&gt;-- s3_inv:  key (URL-decoded), size, e_tag       from S3 Inventory&lt;/span&gt;
&lt;span class="c1"&gt;-- gcs_inv: name, size, source_etag             from the bucket listing (metadata x-goog-source-etag)&lt;/span&gt;
&lt;span class="k"&gt;SELECT&lt;/span&gt;
  &lt;span class="k"&gt;COUNT&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                                          &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;s3_objects&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;COUNTIF&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;g&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="k"&gt;IS&lt;/span&gt; &lt;span class="k"&gt;NULL&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                           &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;missing_in_gcs&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;COUNTIF&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;g&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="k"&gt;size&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="k"&gt;size&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                         &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;size_mismatch&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;COUNTIF&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;TRIM&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;g&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;source_etag&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'"'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;TRIM&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;e_tag&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'"'&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;etag_mismatch&lt;/span&gt;
&lt;span class="k"&gt;FROM&lt;/span&gt; &lt;span class="n"&gt;s3_inv&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;
&lt;span class="k"&gt;LEFT&lt;/span&gt; &lt;span class="k"&gt;JOIN&lt;/span&gt; &lt;span class="n"&gt;gcs_inv&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="k"&gt;g&lt;/span&gt; &lt;span class="k"&gt;ON&lt;/span&gt; &lt;span class="k"&gt;g&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="k"&gt;key&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Two gotchas in that query. S3 Inventory writes keys URL-encoded in CSV, so a key with a space or a non-ASCII character won't join until you decode it. And normalise quoting on both ETag columns before comparing. On top of the diff, download a random sample, say 0.1% of multipart objects, from both sides and compare SHA-256. That's the only check that doesn't trust either provider's metadata.&lt;/p&gt;

&lt;p&gt;The gates for each bucket: zero missing, zero size mismatches, zero ETag mismatches, zero failed objects in the transfer logs, and a clean sample. Nothing on AWS gets deleted until all five pass.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cutover: delta sync and the deletes problem
&lt;/h2&gt;

&lt;p&gt;Event-driven transfers keep creates in sync after the bulk copy: S3 sends object-create events to SQS and Storage Transfer Service copies each new or changed object. They don't propagate deletes. Deleting an object at the source doesn't delete it in the destination [7].&lt;/p&gt;

&lt;p&gt;The textbook fix is a final full pass with &lt;code&gt;--delete-from=destination-if-unique&lt;/code&gt; during the freeze. That needs a full listing of both sides. For &lt;code&gt;thumbs&lt;/code&gt; that's two million LIST pages per side. If listing runs at 20 pages a second (an assumption, measure yours), one side takes about 28 hours. Even &lt;code&gt;media-originals&lt;/code&gt;, at 40,000 pages, takes over half an hour at that rate. Neither fits in a 30-minute freeze.&lt;/p&gt;

&lt;p&gt;So don't list during the freeze. Capture deletes as they happen instead. &lt;code&gt;s3:ObjectRemoved:*&lt;/code&gt; is a different event type from &lt;code&gt;s3:ObjectCreated:*&lt;/code&gt;, so a second notification to a separate deletes queue doesn't conflict with the sync queue. Start it on the same day as the bulk copy, and replay it after the final creates have drained:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;urllib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;parse&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;boto3&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;botocore.exceptions&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;ClientError&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;google.api_core.exceptions&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;NotFound&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;google.cloud&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;storage&lt;/span&gt;

&lt;span class="n"&gt;SRC&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;acme-media-originals&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;span class="n"&gt;Q&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;https://sqs.us-east-1.amazonaws.com/111122223333/originals-deletes&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;boto3&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;client&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;s3&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;boto3&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;client&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sqs&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;region_name&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;us-east-1&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;dst&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;storage&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Client&lt;/span&gt;&lt;span class="p"&gt;().&lt;/span&gt;&lt;span class="nf"&gt;bucket&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;acme-media-originals&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="n"&gt;msgs&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;receive_message&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;QueueUrl&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;Q&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;MaxNumberOfMessages&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;WaitTimeSeconds&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Messages&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;msgs&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;rec&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;loads&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Body&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]).&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Records&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;[]):&lt;/span&gt;
            &lt;span class="n"&gt;key&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;urllib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;parse&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;unquote_plus&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;rec&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;s3&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;][&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;object&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;][&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;key&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;  &lt;span class="c1"&gt;# event keys are URL-encoded
&lt;/span&gt;            &lt;span class="k"&gt;try&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="n"&gt;s3&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;head_object&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Bucket&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;SRC&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="k"&gt;continue&lt;/span&gt;  &lt;span class="c1"&gt;# deleted then re-created on AWS: keep the GCS copy
&lt;/span&gt;            &lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="n"&gt;ClientError&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="k"&gt;pass&lt;/span&gt;
            &lt;span class="k"&gt;try&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="n"&gt;dst&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;blob&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
            &lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="n"&gt;NotFound&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="k"&gt;pass&lt;/span&gt;
        &lt;span class="n"&gt;sqs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;delete_message&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;QueueUrl&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;Q&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ReceiptHandle&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ReceiptHandle&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;head_object&lt;/code&gt; check matters. A key that was deleted and then re-created on AWS shows up in the deletes queue, and replaying the delete blindly would remove the good copy on GCP. For &lt;code&gt;thumbs&lt;/code&gt;, a stale extra object is harmless because nothing lists the bucket, so we replay its deletes after cutover rather than inside the freeze.&lt;/p&gt;

&lt;p&gt;With that in place, the freeze for each application is short and every step has a gate:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Stop writes&lt;/strong&gt; to the bucket, share or database. Put the app in read-only mode, not fully down.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Drain creates.&lt;/strong&gt; Wait until the sync queue shows zero visible and in-flight messages and the transfer job's last operation has no failures.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Final file share pass.&lt;/strong&gt; Run the last incremental EFS-to-Filestore pass, already timed in the pilot.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Promote the database.&lt;/strong&gt; Confirm replica lag is zero, then promote.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Replay deletes&lt;/strong&gt; from the deletes queue for buckets where stale objects matter.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Diff the last day.&lt;/strong&gt; Re-run the inventory diff on objects created since yesterday's inventory.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Flip configuration&lt;/strong&gt; to the GCS buckets, Filestore mount and new database endpoint, then create the Pub/Sub notifications.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Decide the rollback rule before the freeze, not during it. Storage Transfer Service writes into Cloud Storage and file systems, not into S3, so any writes that land on GCP after the flip must be copied back by your app or a tool like rclone if you roll back. Keep the rollback window short and named: for example, "roll back within the first hour on a 5xx rate above 1%, otherwise roll forward".&lt;/p&gt;

&lt;p&gt;After cutover, watch four numbers against the pre-move baseline: Cloud Storage 429 and 5xx rates (the ramp-up limits apply to read traffic too), p99 origin latency behind the CDN, 404s on &lt;code&gt;thumbs&lt;/code&gt; (missing objects show up here first), and daily Class A and Class B operation counts against the forecast.&lt;/p&gt;

&lt;h2&gt;
  
  
  Backups
&lt;/h2&gt;

&lt;p&gt;AWS Backup becomes Backup and DR Service. It protects Compute Engine VMs, disks, Cloud SQL and more on a schedule, and stores copies in backup vaults with an enforced retention period, which plays the role of AWS Backup Vault Lock. Put the vault in a separate project from the workloads it protects.&lt;/p&gt;

&lt;p&gt;Don't migrate old AWS backups as backups. Let them age out on AWS where retention allows, or restore and copy only what retention rules require you to keep, like &lt;code&gt;audit-archive&lt;/code&gt; here. Start fresh backups on GCP before cutover day, so the first post-cutover restore test isn't the first backup.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the plan costs, all in
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Line item&lt;/th&gt;
&lt;th&gt;Basis&lt;/th&gt;
&lt;th&gt;Cost&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;AWS egress for 400 TB&lt;/td&gt;
&lt;td&gt;Exit credit approved&lt;/td&gt;
&lt;td&gt;$0 (about $11,200 via managed private network, or $23,800 to $27,600 over the internet without the credit)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;S3 GET and LIST requests&lt;/td&gt;
&lt;td&gt;2.06 B GETs at $0.0004 per 1,000, plus LIST pages&lt;/td&gt;
&lt;td&gt;About $830&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Standard-IA retrieval&lt;/td&gt;
&lt;td&gt;130 TB at $0.01 per GB&lt;/td&gt;
&lt;td&gt;About $1,300&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Deep Archive restore&lt;/td&gt;
&lt;td&gt;90 TB Bulk at $0.0025 per GB, plus Batch Operations&lt;/td&gt;
&lt;td&gt;About $235, plus temporary restored copies&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cloud Storage Class A writes&lt;/td&gt;
&lt;td&gt;Thumbs $10,000, originals $200, exports $60, archive $450&lt;/td&gt;
&lt;td&gt;About $10,710&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Exports &lt;code&gt;customTime&lt;/code&gt; update&lt;/td&gt;
&lt;td&gt;6 M Nearline metadata updates&lt;/td&gt;
&lt;td&gt;About $60&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EFS agent transfer&lt;/td&gt;
&lt;td&gt;12 TB at $0.0125 per GiB&lt;/td&gt;
&lt;td&gt;About $140&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Total one-time, excluding egress&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;About $13,300&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Now the run rate. On AWS, the four buckets cost about $5,700 a month: 180 TB of S3 Standard at $0.023 then $0.022 per GB, 130 TB of Standard-IA at $0.0125, and 90 TB of Deep Archive at $0.00099. On GCP in &lt;code&gt;us-central1&lt;/code&gt;, the same data costs about $5,000: Standard at $0.020 per GiB, Nearline at $0.010 and Archive at $0.0012 [1][19]. That's a saving of roughly $700 a month, and it's on a like-for-like basis that ignores units and discounts.&lt;/p&gt;

&lt;p&gt;The honest reading: storage savings alone take about 19 months to pay back the one-time operations bill, and the operations bill is mostly one bucket's object count. If the move is justified, it's by the GCP commit and the rest of the platform, not by storage list prices. Know that before someone asks.&lt;/p&gt;

&lt;h2&gt;
  
  
  What we'd do first
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Turn on S3 Inventory&lt;/strong&gt; for every bucket today. Count objects, not just bytes. The object count drives the write bill, the timeline and the verification plan.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ask AWS Support about the exit credit&lt;/strong&gt; and get the window and scope confirmed in writing before the first byte moves.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reserve bucket names.&lt;/strong&gt; They're global on both clouds, and the one you want may be taken.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Start the archive restore early.&lt;/strong&gt; It's the longest wait with the least effort.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pilot one prefix of the largest-object-count bucket.&lt;/strong&gt; Measure objects per second, listing speed and the verification diff. Every other estimate in the plan comes from these numbers.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wire the deletes queue and the sync queue&lt;/strong&gt; on the same day as the bulk copy starts.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Common questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  How do I transfer data from S3 to Google Cloud Storage?
&lt;/h3&gt;

&lt;p&gt;Use Storage Transfer Service with a federated AWS IAM role. It reads S3 directly, validates checksums, skips unchanged objects on later runs and logs failures. Add an event-driven transfer through SQS to keep buckets in sync until cutover, and handle deletes separately, because event-driven transfers don't propagate them.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does AWS charge to move data out to GCP?
&lt;/h3&gt;

&lt;p&gt;Normally yes, per GB. AWS waives internet data transfer out for eligible customers moving all their data, or all data for a service, off AWS. Request it through AWS Support before you start, and confirm the completion window in writing: AWS's post currently says 180 days outside the EU. If you don't qualify, Storage Transfer Service's managed private network avoids S3 internet egress for a per-GiB fee.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can Storage Transfer Service copy S3 Glacier objects?
&lt;/h3&gt;

&lt;p&gt;Not while they're archived. Glacier Flexible Retrieval objects are skipped by default, and Deep Archive objects are copied only after a restore. Restore in waves with S3 Batch Operations, then copy.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the GCP equivalent of S3 Glacier?
&lt;/h3&gt;

&lt;p&gt;Coldline and Archive. Both return data in milliseconds with no restore step. Coldline has a 90-day minimum storage duration and Archive has 365 days, longer than Deep Archive's 180.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is Google Cloud Storage S3 compatible?
&lt;/h3&gt;

&lt;p&gt;Partly. The XML API accepts many S3 requests with HMAC keys at &lt;code&gt;storage.googleapis.com&lt;/code&gt;. It's a useful bridge during a move, but not every S3 feature works, so move code to the Google client libraries.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the GCP equivalent of EFS?
&lt;/h3&gt;

&lt;p&gt;Filestore for NFS, and Google Cloud NetApp Volumes when you need SMB or NetApp features. Filestore bills for provisioned capacity, so size it from measured usage.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do I verify an S3 to GCS migration?
&lt;/h3&gt;

&lt;p&gt;Diff S3 Inventory against a Cloud Storage listing on key, size and the &lt;code&gt;x-goog-source-etag&lt;/code&gt; metadata that Storage Transfer Service writes. Don't expect S3 ETags to match Cloud Storage MD5s, because multipart and SSE-KMS ETags aren't MD5. Sample-download a fraction of objects from both sides and compare SHA-256.&lt;/p&gt;

&lt;h2&gt;
  
  
  How MigrateX handles this
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" alt="MigrateX" width="799" height="293"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;MigrateX is our platform and service for moving software, data and infrastructure from one technology to another. Automation does the repetitive work, and experienced engineers make the decisions this post walks through.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Assessment.&lt;/strong&gt; We pull inventories for every bucket, volume, share and backup, and count objects as well as bytes. We find the ties to AWS that break at cutover: hard-coded S3 URLs, notification wiring, bucket policies and long-lived access keys.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cost and timeline model.&lt;/strong&gt; We model egress options, per-object write costs, restore costs and storage classes for your data, so the one-time bill and the run rate are known before anything moves.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Migration in waves.&lt;/strong&gt; Automation generates the Terraform for buckets, IAM and lifecycle rules, and sets up transfer jobs, sync queues and deletes queues. Our engineers own the parts that need judgement: the class decisions, the database cutover and the freeze runbook.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Proof.&lt;/strong&gt; Every bucket passes an inventory diff, a checksum sample and a failed-object check before anything on AWS is deleted.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Handover.&lt;/strong&gt; We retire AWS storage wave by wave, set up Backup and DR on GCP, and leave your team with storage they understand and own.&lt;/li&gt;
&lt;/ol&gt;

&lt;blockquote&gt;
&lt;p&gt;Planning a move from AWS to GCP? Tell us about your setup through &lt;a href="https://cobuildx.ai/contact" rel="noopener noreferrer"&gt;Contact Us&lt;/a&gt;, and we'll start with a free conversation about where the object counts, archives and cutover windows put the real work.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Google Cloud
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Storage pricing&lt;/em&gt; (storage, operations, retrieval, minimum storage duration, early deletion, Autoclass fee). &lt;a href="https://cloud.google.com/storage/pricing" rel="noopener noreferrer"&gt;https://cloud.google.com/storage/pricing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Transfer from Amazon S3 to Cloud Storage&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage-transfer/docs/create-transfers/agentless/s3" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage-transfer/docs/create-transfers/agentless/s3&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Transfer over a Google-managed private network&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage-transfer/docs/create-transfers/agentless/managed-private-network" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage-transfer/docs/create-transfers/agentless/managed-private-network&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Storage Transfer Service pricing&lt;/em&gt;. &lt;a href="https://cloud.google.com/storage-transfer/pricing" rel="noopener noreferrer"&gt;https://cloud.google.com/storage-transfer/pricing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Request rate and access distribution guidelines&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage/docs/request-rate" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage/docs/request-rate&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Metadata preservation&lt;/em&gt; (Storage Transfer Service). &lt;a href="https://docs.cloud.google.com/storage-transfer/docs/metadata-preservation" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage-transfer/docs/metadata-preservation&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Event-driven transfers from AWS S3&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage-transfer/docs/event-driven-aws" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage-transfer/docs/event-driven-aws&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Data integrity&lt;/em&gt; (Storage Transfer Service). &lt;a href="https://docs.cloud.google.com/storage-transfer/docs/data-integrity" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage-transfer/docs/data-integrity&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Hyperdisk overview&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/compute/docs/disks/hyperdisks" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/compute/docs/disks/hyperdisks&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Filestore service tiers&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/filestore/docs/service-tiers" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/filestore/docs/service-tiers&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Hashes and ETags: best practices&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage/docs/hashes-etags" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage/docs/hashes-etags&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;gcloud transfer jobs create&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/sdk/gcloud/reference/transfer/jobs/create" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/sdk/gcloud/reference/transfer/jobs/create&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Storage classes&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage/docs/storage-classes" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage/docs/storage-classes&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Autoclass&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage/docs/autoclass" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage/docs/autoclass&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Uniform bucket-level access&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage/docs/uniform-bucket-level-access" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage/docs/uniform-bucket-level-access&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Google Cloud NetApp Volumes&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/netapp/volumes/docs/discover/overview" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/netapp/volumes/docs/discover/overview&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Backup and DR Service&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/backup-disaster-recovery/docs/concepts/backup-dr" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/backup-disaster-recovery/docs/concepts/backup-dr&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  AWS
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;AWS. &lt;em&gt;Free data transfer out to internet when moving out of AWS&lt;/em&gt; (with later updates to the completion window). &lt;a href="https://aws.amazon.com/blogs/aws/free-data-transfer-out-to-internet-when-moving-out-of-aws/" rel="noopener noreferrer"&gt;https://aws.amazon.com/blogs/aws/free-data-transfer-out-to-internet-when-moving-out-of-aws/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon S3 pricing&lt;/em&gt; (US East, N. Virginia). &lt;a href="https://aws.amazon.com/s3/pricing/" rel="noopener noreferrer"&gt;https://aws.amazon.com/s3/pricing/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon EC2 On-Demand pricing: data transfer&lt;/em&gt;. &lt;a href="https://aws.amazon.com/ec2/pricing/on-demand/" rel="noopener noreferrer"&gt;https://aws.amazon.com/ec2/pricing/on-demand/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Understanding archive retrieval options&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/restoring-objects-retrieval-options.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/restoring-objects-retrieval-options.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Restore objects with Batch Operations&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-initiate-restore-object.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-initiate-restore-object.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Restoring an archived object&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/restoring-objects.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/restoring-objects.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Understanding and managing Amazon S3 storage classes&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Configuring event notifications using object key name filtering&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-filtering.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-filtering.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Object&lt;/em&gt; (ETag semantics), Amazon S3 API Reference. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_Object.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/API/API_Object.html&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;CobuildX helps teams migrate legacy applications and cloud infrastructure with &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;MigrateX&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-storage" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>aws</category>
      <category>googlecloud</category>
      <category>cloud</category>
      <category>devops</category>
    </item>
    <item>
      <title>Moving Serverless from AWS to GCP: Lambda, Fargate and Events</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Thu, 05 Nov 2026 09:22:22 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/moving-serverless-from-aws-to-gcp-lambda-fargate-and-events-2h3b</link>
      <guid>https://dev.to/cobuildx-ai/moving-serverless-from-aws-to-gcp-lambda-fargate-and-events-2h3b</guid>
      <description>&lt;p&gt;&lt;em&gt;An order platform of 30 Lambdas, SQS queues, EventBridge rules and a Step Functions workflow, moved to Cloud Run, Pub/Sub and Workflows. The cost math at 300 million requests a month, the code that breaks at concurrency 40, the queue semantics that change, the workflow gaps and a traffic-shifted cutover.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;You run an order platform on about 30 Lambda functions. Twenty-two of them sit behind an API Gateway HTTP API, six read from SQS queues fed by EventBridge rules, and one Step Functions state machine takes every order from "placed" to "paid" to "shipped". The Postgres database has already moved to Cloud SQL. Leadership signed a Google Cloud commit, and the serverless tier is next.&lt;/p&gt;

&lt;p&gt;There are no servers to copy, so the move looks small. It isn't. Every one of those functions was written against Lambda's defaults: one request per execution environment, SQS batches with a visibility timeout, EventBridge rules that match on the event body, and a state machine with a 256 KiB payload. Google Cloud changes every one of those defaults. This post works through the decisions in the order we'd make them, with the numbers that drive each one, the option we'd reject, and what we'd measure before and after cutover.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;This post covers serverless.&lt;/strong&gt; For EC2, EKS and GPUs, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-compute-options" rel="noopener noreferrer"&gt;moving compute from AWS to GCP&lt;/a&gt;. For S3, EBS and EFS, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-storage" rel="noopener noreferrer"&gt;moving storage from AWS to GCP&lt;/a&gt;. For EMR, Glue and Redshift, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-big-data" rel="noopener noreferrer"&gt;moving big data from AWS to GCP&lt;/a&gt;. Going the other way? Read &lt;a href="https://cobuildx.ai/blog/gcp-to-aws-serverless" rel="noopener noreferrer"&gt;moving serverless from GCP to AWS&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  The workload we're moving
&lt;/h2&gt;

&lt;p&gt;The scenario is illustrative, not a customer: a representative shape we use to make the trade-offs concrete. Swap in your own numbers; the method stays the same.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Component&lt;/th&gt;
&lt;th&gt;On AWS today&lt;/th&gt;
&lt;th&gt;Volume and shape (assumed)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Public API&lt;/td&gt;
&lt;td&gt;22 Lambdas (Node.js, 1,024 MB) behind an HTTP API with a JWT authorizer&lt;/td&gt;
&lt;td&gt;300 million requests a month, about 116 per second on average, peaks near 600. Mean billed duration 120 ms, of which roughly 100 ms waits on Postgres or a payment provider&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Invoice renderer&lt;/td&gt;
&lt;td&gt;1 Lambda, 2,048 MB&lt;/td&gt;
&lt;td&gt;2 million PDFs a month, 800 ms each, almost all CPU&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Async consumers&lt;/td&gt;
&lt;td&gt;6 Lambdas on SQS event source mappings, batch size 10, partial batch responses on&lt;/td&gt;
&lt;td&gt;10 million messages a month from EventBridge rules on an &lt;code&gt;orders&lt;/code&gt; bus&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Order workflow&lt;/td&gt;
&lt;td&gt;1 Standard Step Functions state machine, with a &lt;code&gt;.waitForTaskToken&lt;/code&gt; step for payment confirmation&lt;/td&gt;
&lt;td&gt;1 million executions a month, about 12 state transitions each&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Schedules&lt;/td&gt;
&lt;td&gt;EventBridge Scheduler: nightly settlement, hourly stock sync&lt;/td&gt;
&lt;td&gt;Small&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Database&lt;/td&gt;
&lt;td&gt;Cloud SQL for PostgreSQL (already moved), reached from AWS over HA VPN&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;max_connections&lt;/code&gt; set to 400&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The mapping itself fits on one page. It is a useful checklist, but it doesn't make any of the decisions that follow:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0xtormlpie1zekidey3i.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0xtormlpie1zekidey3i.png" alt="Serverless service map from AWS to Google Cloud: Lambda to Cloud Run functions, Fargate and App Runner to Cloud Run services, API Gateway to Cloud Run direct or API Gateway or Apigee, EventBridge to Eventarc, SQS and SNS to Pub/Sub or Cloud Tasks, EventBridge Scheduler to Cloud Scheduler, and Step Functions to Workflows, with what to watch for on each" width="800" height="502"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Why the API moves now: while Postgres lives in Google Cloud and the API lives in AWS, every query from every Lambda crosses the VPN. That round trip is paid on each of 300 million requests a month, and it stops the day the API moves.&lt;/p&gt;

&lt;h2&gt;
  
  
  Decision 1: functions or services, and which billing mode
&lt;/h2&gt;

&lt;p&gt;Cloud Run functions and Cloud Run services run on the same platform. The real choice is not the product name, it is how many requests one instance serves at once and how you are billed for the time it is alive.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fawz0n1n1u81o8l3mor0u.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fawz0n1n1u81o8l3mor0u.png" alt="How requests reach your code: on standard AWS Lambda, each request gets its own execution environment, so 80 requests need 80 environments; on Cloud Run and Cloud Run functions, up to 80 or more requests share one instance" width="799" height="247"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Lambda bills each request for its own duration times its memory, even if 100 ms of a 120 ms request is spent waiting on a socket. Cloud Run bills &lt;strong&gt;instance time&lt;/strong&gt;: while an instance is serving, it is billed once whether it is handling 1 request or 40. Concurrency defaults to 80 per instance (80 per vCPU when you deploy with gcloud or Terraform) and goes up to 1,000 [2]. There are two billing modes [3]:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Request-based:&lt;/strong&gt; you pay only while an instance is starting, serving or shutting down, plus a per-request fee. In us-central1 that is $0.000024 per vCPU-second, $0.0000025 per GiB-second and $0.40 per million requests [10].&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Instance-based:&lt;/strong&gt; you pay for the whole life of every instance, busy or idle, with no per-request fee and full CPU outside requests. In us-central1 that is $0.000018 per vCPU-second and $0.000002 per GiB-second [10].&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  The worked cost comparison
&lt;/h3&gt;

&lt;p&gt;List prices as of November 2026, AWS in us-east-1 and Google Cloud in us-central1, free tiers ignored on both sides, 30-day month. For Cloud Run we consolidate the 22 API Lambdas into one service with 1 vCPU, 1 GiB and concurrency 40. Average in-flight requests are 116 per second times 0.12 s, about 14 (Little's law). We assume the autoscaler holds an average of 3 instances, each serving almost continuously: 3 × 2,592,000 s = 7,776,000 instance-seconds. That instance count is the assumption to check first, from the &lt;code&gt;instance_count&lt;/code&gt; metric during the shadow phase described below.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Line item&lt;/th&gt;
&lt;th&gt;Lambda + HTTP API&lt;/th&gt;
&lt;th&gt;Cloud Run, request-based&lt;/th&gt;
&lt;th&gt;Cloud Run, instance-based&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Requests&lt;/td&gt;
&lt;td&gt;300M × $0.20/M = $60&lt;/td&gt;
&lt;td&gt;300M × $0.40/M = $120&lt;/td&gt;
&lt;td&gt;None&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Compute&lt;/td&gt;
&lt;td&gt;300M × 0.12 s × 1 GB = 36M GB-s × $0.0000166667 = $600&lt;/td&gt;
&lt;td&gt;CPU 7.776M vCPU-s = $186.62; memory 7.776M GiB-s = $19.44&lt;/td&gt;
&lt;td&gt;CPU 7.776M vCPU-s = $139.97; memory 7.776M GiB-s = $15.55&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;API front door&lt;/td&gt;
&lt;td&gt;HTTP API, 300M × $1.00/M = $300&lt;/td&gt;
&lt;td&gt;None (JWT checked in middleware)&lt;/td&gt;
&lt;td&gt;None (JWT checked in middleware)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Monthly total&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;$960&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;$326&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;$156&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Sources for the AWS lines: Lambda at $0.20 per million requests and $0.0000166667 per GB-second [13], HTTP APIs at $1.00 per million in the first tier [14]. If you put a global external Application Load Balancer in front for a custom domain and Cloud Armor, add its forwarding rule and data processing charges to both Cloud Run columns.&lt;/p&gt;

&lt;p&gt;Two thresholds come out of this table, and they are the part worth keeping:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;When concurrency stops paying.&lt;/strong&gt; Request-based Cloud Run matches the $960 AWS bill at about 12 always-busy instances (12.2 × 2,592,000 s × $0.0000265 + $120 ≈ $960). With 14 requests in flight, that is roughly 1.1 requests per instance. If your service can't safely run more than one request per instance, the saving disappears and the per-request fee is twice Lambda's.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;When instance-based billing wins.&lt;/strong&gt; Instance-based CPU plus memory costs $0.00002 per second against $0.0000265 for request-based. Instance-based is cheaper once instances are busy more than about 75% of their lifetime, and earlier when the per-request fee is a big share of the bill, as it is here. Spiky APIs that sit idle at night belong on request-based billing; steady APIs like this one belong on instance-based.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  The counter-example: the invoice renderer
&lt;/h3&gt;

&lt;p&gt;The renderer burns CPU for 800 ms and waits on nothing. On Lambda: 2M × 0.8 s × 2 GB = 3.2M GB-s, or $53.33, plus $0.40 in requests: &lt;strong&gt;$53.73&lt;/strong&gt;. On Cloud Run at concurrency 1, 1 vCPU and 2 GiB, request-based: 1.6M instance-seconds gives $38.40 CPU, $8.00 memory and $0.80 in requests: &lt;strong&gt;$47.20&lt;/strong&gt;. That is a wash. Raising concurrency would not help, because two PDFs on one vCPU take twice as long each and p99 latency doubles. We'd move it as a Cloud Run function at concurrency 1 for the simple deploy, and expect no saving.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;The saving comes from waiting, not from Google.&lt;/strong&gt; I/O-bound APIs with real concurrency get cheaper. CPU-bound functions cost about the same. Model your top five functions before you promise anyone a number.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h3&gt;
  
  
  Where everything else lands
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpxku88sa10halfn83nhk.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpxku88sa10halfn83nhk.png" alt="Serverless decision flow: if it is a small function behind an event or webhook, use Cloud Run functions; if it is a container or web app, use a Cloud Run service; if it pulls from a queue with no HTTP endpoint, use a Cloud Run worker pool; if it runs to completion on a schedule, use a Cloud Run job with Cloud Scheduler; if it chains several steps, use Workflows" width="800" height="421"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Piece&lt;/th&gt;
&lt;th&gt;Our pick&lt;/th&gt;
&lt;th&gt;Rejected option, and when we'd flip&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;22 API Lambdas&lt;/td&gt;
&lt;td&gt;One Cloud Run service, instance-based billing, concurrency 40&lt;/td&gt;
&lt;td&gt;22 separate functions: keeps per-route IAM and deploys, but each idles on its own and the concurrency saving shrinks. Flip if routes have very different memory or security needs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;API Gateway + JWT authorizer&lt;/td&gt;
&lt;td&gt;Cloud Run direct, JWT verified in shared middleware&lt;/td&gt;
&lt;td&gt;Google API Gateway: adds OpenAPI-driven key and JWT checks and its own per-call charge. Apigee: only for monetized partner APIs with quotas and a developer portal. Flip to API Gateway if you sell API keys&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Invoice renderer&lt;/td&gt;
&lt;td&gt;Cloud Run function, concurrency 1&lt;/td&gt;
&lt;td&gt;Folding it into the API service: one CPU-heavy route would set instance size for all the cheap ones&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Nightly settlement&lt;/td&gt;
&lt;td&gt;Cloud Run job started by Cloud Scheduler&lt;/td&gt;
&lt;td&gt;A long HTTP request on the API service: request timeout tops out at 60 minutes [4] and a job retries per task&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Hourly stock sync&lt;/td&gt;
&lt;td&gt;Cloud Scheduler calling a Cloud Run function over HTTP with an OIDC token&lt;/td&gt;
&lt;td&gt;Eventarc: nothing to route, just a clock&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fargate or App Runner containers (if any)&lt;/td&gt;
&lt;td&gt;Cloud Run service with the same image; worker pools for queue pullers; jobs for run-to-completion tasks [5]&lt;/td&gt;
&lt;td&gt;GKE: only for GPUs, host networking or node control&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;For containers coming off Fargate or App Runner, three checks catch most first-deploy failures: the server listens on &lt;code&gt;$PORT&lt;/code&gt; (8080 by default), App Mesh, X-Ray daemon and FireLens sidecars are replaced by Cloud Trace and Cloud Logging, and any work that continues after the response is sent runs on instance-based billing, because request-based instances get CPU only while serving. Cloud Run jobs give each parallel task its index in &lt;code&gt;CLOUD_RUN_TASK_INDEX&lt;/code&gt;, the way AWS Batch array jobs use &lt;code&gt;AWS_BATCH_JOB_ARRAY_INDEX&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The smaller differences still each need a decision, usually once for all functions:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Topic&lt;/th&gt;
&lt;th&gt;AWS&lt;/th&gt;
&lt;th&gt;Google Cloud&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Entry point&lt;/td&gt;
&lt;td&gt;&lt;code&gt;handler(event, context)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Functions Framework (&lt;code&gt;http&lt;/code&gt; or &lt;code&gt;cloud_event&lt;/code&gt;) or any HTTP server in a container&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Longest run&lt;/td&gt;
&lt;td&gt;15 minutes&lt;/td&gt;
&lt;td&gt;60 minutes for HTTP, 9 minutes for event-driven functions [1]. Longer event work goes to a Cloud Run job&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Shared code&lt;/td&gt;
&lt;td&gt;Layers&lt;/td&gt;
&lt;td&gt;No layers: a shared package or a base container image&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Memory and CPU&lt;/td&gt;
&lt;td&gt;Set memory; CPU grows with it&lt;/td&gt;
&lt;td&gt;Set CPU and memory separately&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Staying warm&lt;/td&gt;
&lt;td&gt;Provisioned concurrency or SnapStart&lt;/td&gt;
&lt;td&gt;Minimum instances, billed at a lower rate while idle on request-based billing [10]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fan-out to many readers&lt;/td&gt;
&lt;td&gt;SNS topic&lt;/td&gt;
&lt;td&gt;Pub/Sub topic with one subscription per reader. Email and SMS subscriptions have no match&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ordered queue&lt;/td&gt;
&lt;td&gt;SQS FIFO&lt;/td&gt;
&lt;td&gt;Pub/Sub ordering keys, or Cloud Tasks with a concurrency of one&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rate-limited calls, one-off delayed tasks&lt;/td&gt;
&lt;td&gt;SQS delay, EventBridge Scheduler one-time schedules&lt;/td&gt;
&lt;td&gt;Cloud Tasks. Cloud Scheduler is cron only, with time zones&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Observability&lt;/td&gt;
&lt;td&gt;CloudWatch Logs, alarms, X-Ray&lt;/td&gt;
&lt;td&gt;Cloud Logging, Cloud Monitoring, Cloud Trace. Rebuild alerts before any traffic moves&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="c1"&gt;# The API service as Terraform: was 22 aws_lambda_function resources and an aws_apigatewayv2_api&lt;/span&gt;
&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_cloud_run_v2_service"&lt;/span&gt; &lt;span class="s2"&gt;"api"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;     &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"orders-api"&lt;/span&gt;
  &lt;span class="nx"&gt;location&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"us-central1"&lt;/span&gt;
  &lt;span class="nx"&gt;template&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;service_account&lt;/span&gt;                  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_service_account&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;orders_api&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;email&lt;/span&gt;  &lt;span class="c1"&gt;# was the execution role&lt;/span&gt;
    &lt;span class="nx"&gt;max_instance_request_concurrency&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;40&lt;/span&gt;
    &lt;span class="nx"&gt;timeout&lt;/span&gt;                          &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"30s"&lt;/span&gt;
    &lt;span class="nx"&gt;scaling&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nx"&gt;min_instance_count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;
      &lt;span class="nx"&gt;max_instance_count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;15&lt;/span&gt;  &lt;span class="c1"&gt;# derived from the DB connection budget below&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="nx"&gt;containers&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nx"&gt;image&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"us-docker.pkg.dev/shop-prod/apps/orders-api:2.0.0"&lt;/span&gt;
      &lt;span class="nx"&gt;resources&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nx"&gt;limits&lt;/span&gt;            &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;cpu&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"1"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;memory&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"1Gi"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="nx"&gt;cpu_idle&lt;/span&gt;          &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;  &lt;span class="c1"&gt;# instance-based billing&lt;/span&gt;
      &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="nx"&gt;vpc_access&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="nx"&gt;network_interfaces&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;network&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"shop-vpc"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;subnetwork&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"run-us-central1"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
      &lt;span class="nx"&gt;egress&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"PRIVATE_RANGES_ONLY"&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Decision 2: what breaks at concurrency 40
&lt;/h2&gt;

&lt;p&gt;The cost table assumes the code is safe with 40 requests in one process. Lambda code usually isn't, because it never had to be. Here is the bug we'd look for first:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Fine on Lambda: one request per execution environment&lt;/span&gt;
&lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="nx"&gt;currentTenant&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// module scope&lt;/span&gt;

&lt;span class="nx"&gt;exports&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;handler&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;async &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;event&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;currentTenant&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;requestContext&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;authorizer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;jwt&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;claims&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;tenant_id&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;order&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;loadOrder&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;pathParameters&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;  &lt;span class="c1"&gt;// yields to the event loop&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;writeAudit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;order&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;  &lt;span class="c1"&gt;// reads currentTenant&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="c1"&gt;// On Cloud Run at concurrency 40, request B overwrites currentTenant while&lt;/span&gt;
&lt;span class="c1"&gt;// request A awaits Postgres. A's audit row is written under B's tenant.&lt;/span&gt;
&lt;span class="c1"&gt;// No error, no log line. Fix: carry request state in AsyncLocalStorage.&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;AsyncLocalStorage&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;require&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;node:async_hooks&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;reqCtx&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;AsyncLocalStorage&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;

&lt;span class="nx"&gt;app&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;use&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="nx"&gt;req&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;res&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;next&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nx"&gt;reqCtx&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt; &lt;span class="na"&gt;tenant&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;req&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;auth&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;tenant_id&lt;/span&gt; &lt;span class="p"&gt;},&lt;/span&gt; &lt;span class="nx"&gt;next&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;tenant&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nx"&gt;reqCtx&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getStore&lt;/span&gt;&lt;span class="p"&gt;().&lt;/span&gt;&lt;span class="nx"&gt;tenant&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Python has the same problem with module globals, and &lt;code&gt;contextvars&lt;/code&gt; is the fix. The other failure modes, in the order they tend to show up:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Fixed &lt;code&gt;/tmp&lt;/code&gt; paths.&lt;/strong&gt; &lt;code&gt;/tmp/invoice.pdf&lt;/code&gt; written by two requests at once produces one customer's PDF in another's email. Use a per-request temp directory (&lt;code&gt;fs.mkdtemp&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Memory, not CPU, runs out first.&lt;/strong&gt; Cloud Run's filesystem is in memory and counts against the instance limit. 40 concurrent requests each buffering a 20 MB file is 800 MB, which leaves 224 MiB of a 1 GiB instance for the runtime. Expect the instance to be killed for exceeding memory before you see high CPU.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Per-request SDK clients.&lt;/strong&gt; Lambda code often creates a client per invocation because it was cheap there. At concurrency 40 that is 40 TLS handshakes per instance. Create clients once per process.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Connection pools that were sized for one.&lt;/strong&gt; A Lambda that opens one connection is fine. A Cloud Run instance needs a real pool, and the pool size sets the instance cap.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The connection math for this scenario: Postgres allows 400 connections. We reserve 50 for admin and migrations, 100 for the async consumers and 100 for the Lambdas still taking traffic during the split. That leaves 150 for the API service. With a pool of 10 per instance, &lt;code&gt;max_instance_count&lt;/code&gt; is 15. Peak demand is 600 req/s × 0.12 s = 72 in flight, which is 2 instances at concurrency 40, so 15 leaves plenty of headroom. On the AWS side, set reserved concurrency on the API Lambdas so they can't exceed their 100 during the split; RDS Proxy can't front Cloud SQL.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How we'd detect a concurrency bug before customers do:&lt;/strong&gt; deploy at concurrency 1, run a load test that sends requests for many tenants and asserts the tenant in each response and audit row matches the token that made the call, then raise concurrency to 5, 20 and 40 with the same test. A mismatch at 5 that didn't happen at 1 is a shared-state bug. Leave services you haven't audited at concurrency 1; you lose the saving, not correctness.&lt;/p&gt;

&lt;h2&gt;
  
  
  Decision 3: SQS and EventBridge to Pub/Sub
&lt;/h2&gt;

&lt;p&gt;Both systems deliver at least once. The differences are in who controls the clock and what happens to a message that keeps failing:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Behaviour&lt;/th&gt;
&lt;th&gt;SQS with a Lambda event source mapping&lt;/th&gt;
&lt;th&gt;Pub/Sub push subscription to Cloud Run&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Delivery unit&lt;/td&gt;
&lt;td&gt;Batches of up to 10,000 (standard queue), partial batch responses [16]&lt;/td&gt;
&lt;td&gt;One message per HTTPS request [8]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Time to finish&lt;/td&gt;
&lt;td&gt;Visibility timeout: 30 s default, extendable per message, 12 hours max [15]. AWS recommends at least 6× the function timeout [16]&lt;/td&gt;
&lt;td&gt;Ack deadline: 10 s default, 10 to 600 s, set per subscription and not per message for push [9]. If the deadline passes while you're still working, the message is sent again&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Success signal&lt;/td&gt;
&lt;td&gt;Function returns; failed IDs listed in &lt;code&gt;batchItemFailures&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;HTTP 102, 200, 201, 202 or 204. Anything else is a nack [8]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Retries&lt;/td&gt;
&lt;td&gt;Message reappears after the visibility timeout&lt;/td&gt;
&lt;td&gt;Immediate by default, or exponential backoff between 10 and 600 s [9]. Push backoff of 100 ms to 60 s applies to the &lt;strong&gt;whole subscription&lt;/strong&gt; after nacks [8]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dead letters&lt;/td&gt;
&lt;td&gt;Redrive policy, &lt;code&gt;maxReceiveCount&lt;/code&gt; (AWS suggests at least 5) [16]&lt;/td&gt;
&lt;td&gt;Dead-letter topic, 5 to 100 attempts, default 5, counted approximately. Needs IAM grants for the Pub/Sub service agent or it silently doesn't work [11]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Exactly once&lt;/td&gt;
&lt;td&gt;FIFO queues, within the deduplication window&lt;/td&gt;
&lt;td&gt;Pull subscriptions only, within one region [12]. Not push&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Retention&lt;/td&gt;
&lt;td&gt;Per queue&lt;/td&gt;
&lt;td&gt;7 days default, up to 31 [9]&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;What that means for the six consumers:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Long handlers can't be push consumers.&lt;/strong&gt; Our fulfilment consumer sometimes calls a carrier API for 3 minutes. Push works with an ack deadline of 300 s. Anything that can exceed 600 s goes to a pull consumer on a Cloud Run worker pool, which can extend deadlines as it works, or hands the work to a Cloud Run job.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One poison message slows everyone.&lt;/strong&gt; Because push backoff is subscription-wide, a burst of nacks from one malformed order throttles delivery of every healthy order on that subscription. Return 2xx for messages you will never be able to process, write them to your own error table, and save nacks for transient failures.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Batches become requests.&lt;/strong&gt; 10 million messages are 10 million Cloud Run requests, not 1 million batched invocations. At concurrency 40 that is cheap in compute, but it is $4 in request fees on request-based billing, and per-message database writes replace per-batch ones.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;EventBridge patterns don't carry over as-is.&lt;/strong&gt; EventBridge rules match on fields inside &lt;code&gt;detail&lt;/code&gt;. Pub/Sub subscription filters match only message &lt;strong&gt;attributes&lt;/strong&gt;, are capped at 256 bytes, and can't be changed after the subscription is created [17]. Promote every field a rule matches on (&lt;code&gt;event_type&lt;/code&gt;, &lt;code&gt;region&lt;/code&gt;, &lt;code&gt;channel&lt;/code&gt;) to an attribute at publish time, and decide filters up front. For Google-sourced events (Cloud Storage uploads, audit logs), Eventarc is the router, and it delivers CloudEvents with &lt;code&gt;type&lt;/code&gt;, &lt;code&gt;source&lt;/code&gt; and &lt;code&gt;data&lt;/code&gt; instead of &lt;code&gt;detail-type&lt;/code&gt;, &lt;code&gt;source&lt;/code&gt; and &lt;code&gt;detail&lt;/code&gt; [7].
&lt;/li&gt;
&lt;/ul&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_pubsub_subscription"&lt;/span&gt; &lt;span class="s2"&gt;"fulfilment"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;                 &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"orders-fulfilment"&lt;/span&gt;
  &lt;span class="nx"&gt;topic&lt;/span&gt;                &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_pubsub_topic&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;orders&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;ack_deadline_seconds&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;300&lt;/span&gt;  &lt;span class="c1"&gt;# longest observed handler time plus margin; max 600&lt;/span&gt;
  &lt;span class="nx"&gt;filter&lt;/span&gt;               &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"attributes.event_type = &lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s2"&gt;order.paid&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;  &lt;span class="c1"&gt;# immutable&lt;/span&gt;

  &lt;span class="nx"&gt;push_config&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;push_endpoint&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;google_cloud_run_v2_service&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;fulfilment&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;uri&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;/pubsub"&lt;/span&gt;
    &lt;span class="nx"&gt;oidc_token&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;service_account_email&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_service_account&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;pubsub_push&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;email&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="nx"&gt;retry_policy&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;minimum_backoff&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"10s"&lt;/span&gt;
    &lt;span class="nx"&gt;maximum_backoff&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"600s"&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="nx"&gt;dead_letter_policy&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;dead_letter_topic&lt;/span&gt;     &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_pubsub_topic&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;orders_dlq&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
    &lt;span class="nx"&gt;max_delivery_attempts&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="c1"&gt;# Without these two grants the dead-letter policy does nothing.&lt;/span&gt;
&lt;span class="nx"&gt;locals&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;pubsub_agent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"serviceAccount:service-&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="k"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;google_project&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;number&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;@gcp-sa-pubsub.iam.gserviceaccount.com"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_pubsub_topic_iam_member"&lt;/span&gt; &lt;span class="s2"&gt;"dlq_publish"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;topic&lt;/span&gt;  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_pubsub_topic&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;orders_dlq&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;role&lt;/span&gt;   &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"roles/pubsub.publisher"&lt;/span&gt;
  &lt;span class="nx"&gt;member&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;local&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;pubsub_agent&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_pubsub_subscription_iam_member"&lt;/span&gt; &lt;span class="s2"&gt;"src_subscribe"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;subscription&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_pubsub_subscription&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;fulfilment&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;role&lt;/span&gt;         &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"roles/pubsub.subscriber"&lt;/span&gt;
  &lt;span class="nx"&gt;member&lt;/span&gt;       &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;local&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;pubsub_agent&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Idempotency, keyed on the business event
&lt;/h3&gt;

&lt;p&gt;During the migration, the same business event can arrive twice from two different systems: once from SQS on AWS and once from Pub/Sub via the bridge. They carry different message IDs. Deduplicating on &lt;code&gt;messageId&lt;/code&gt; catches Pub/Sub redeliveries but not the cross-cloud duplicate. Key on the business event instead, and record it in the same transaction as the side effect:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="k"&gt;BEGIN&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;INSERT&lt;/span&gt; &lt;span class="k"&gt;INTO&lt;/span&gt; &lt;span class="n"&gt;processed_events&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event_key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;consumer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;VALUES&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'order.paid:ord_8F2K1'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'fulfilment'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;ON&lt;/span&gt; &lt;span class="n"&gt;CONFLICT&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event_key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;consumer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;DO&lt;/span&gt; &lt;span class="k"&gt;NOTHING&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="c1"&gt;-- 0 rows inserted: already handled, COMMIT and return 204&lt;/span&gt;
&lt;span class="c1"&gt;-- 1 row inserted: create the shipment in this same transaction, then COMMIT&lt;/span&gt;
&lt;span class="k"&gt;COMMIT&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Count the &lt;code&gt;DO NOTHING&lt;/code&gt; hits as a metric. A steady trickle is normal at-least-once behaviour. A jump during a cutover step means two consumers are live for the same subscription and the step needs a look.&lt;/p&gt;

&lt;h2&gt;
  
  
  Decision 4: the order workflow on Workflows
&lt;/h2&gt;

&lt;p&gt;Step Functions and Workflows cover the same ground: steps, retries, choices, waits, parallel branches and callbacks. The definitions are rewritten by hand, Amazon States Language JSON into Workflows YAML. The gaps that matter for this state machine:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Concern&lt;/th&gt;
&lt;th&gt;Step Functions Standard&lt;/th&gt;
&lt;th&gt;Workflows&lt;/th&gt;
&lt;th&gt;What we do about it&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Data size&lt;/td&gt;
&lt;td&gt;256 KiB per state input or output [18]&lt;/td&gt;
&lt;td&gt;512 KB for all variables in an execution combined; 2 MB per HTTP response [19]&lt;/td&gt;
&lt;td&gt;Pass order IDs, not order documents. Services read from Postgres&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fan-out&lt;/td&gt;
&lt;td&gt;Distributed Map: up to 10,000 parallel child executions [18]&lt;/td&gt;
&lt;td&gt;20 concurrent branches or iterations per execution, 10 branches per parallel step [19]&lt;/td&gt;
&lt;td&gt;Our workflow fans out to 3 to 5 warehouses: fine. Bulk re-processing goes to a Cloud Run job instead&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Wait for an external system&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;.waitForTaskToken&lt;/code&gt;, then &lt;code&gt;SendTaskSuccess&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;events.create_callback_endpoint&lt;/code&gt; and &lt;code&gt;events.await_callback&lt;/code&gt;, 12-hour default timeout. The caller needs &lt;code&gt;workflows.callbacks.send&lt;/code&gt; [20]&lt;/td&gt;
&lt;td&gt;The payment provider can't hold a Google token, so its webhook hits our payments service, which calls the callback URL with its own service account&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Long runs&lt;/td&gt;
&lt;td&gt;1 year max, 25,000 history events [18]&lt;/td&gt;
&lt;td&gt;1 year max, 100,000 steps [19]&lt;/td&gt;
&lt;td&gt;No change&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Short, high-volume flows&lt;/td&gt;
&lt;td&gt;Express workflows, $1.00 per million plus duration [21]&lt;/td&gt;
&lt;td&gt;No separate flavour&lt;/td&gt;
&lt;td&gt;If you had Express workflows, consider plain code in a Cloud Run service&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Concurrency&lt;/td&gt;
&lt;td&gt;Open executions in the millions [18]&lt;/td&gt;
&lt;td&gt;10,000 concurrent per region by default, backlog up to 100,000 [19]. Executions waiting on callbacks count&lt;/td&gt;
&lt;td&gt;1M orders a month with a payment wait of minutes stays far below 10,000. Watch it if waits stretch to days&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Cost, at list price as of November 2026: Step Functions Standard is $0.025 per 1,000 state transitions [21], so 1M executions × 12 transitions = &lt;strong&gt;$300 a month&lt;/strong&gt;. Workflows charges $0.01 per 1,000 internal steps and $0.025 per 1,000 external steps [22]. Assignments count as steps, so the rewrite is about 18 steps per order: 17 internal and one external (&lt;code&gt;await_callback&lt;/code&gt;). That is 17M × $0.01/1,000 + 1M × $0.025/1,000 = &lt;strong&gt;$195 a month&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The catch is in what counts as internal. Calls to Cloud Run on &lt;code&gt;*.run.app&lt;/code&gt; URLs are internal steps. Calls to the same services on a custom domain such as &lt;code&gt;orders.shop.example&lt;/code&gt; are external [22], and every retry attempt is a step. Point the workflow at custom domains and the 17M internal steps become external: $425 for those alone, more than Step Functions.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;main&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;params&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="nv"&gt;order&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
  &lt;span class="na"&gt;steps&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;reserve_stock&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;try&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;http.post&lt;/span&gt;
          &lt;span class="na"&gt;args&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;url&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;https://inventory-abc123-uc.a.run.app/reserve&lt;/span&gt;  &lt;span class="c1"&gt;# run.app: internal step&lt;/span&gt;
            &lt;span class="na"&gt;auth&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="nv"&gt;OIDC&lt;/span&gt; &lt;span class="pi"&gt;}&lt;/span&gt;
            &lt;span class="na"&gt;body&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
              &lt;span class="na"&gt;order_id&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${order.id}&lt;/span&gt;
          &lt;span class="na"&gt;result&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;reservation&lt;/span&gt;
        &lt;span class="na"&gt;retry&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;predicate&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${http.default_retry_predicate}&lt;/span&gt;
          &lt;span class="na"&gt;max_retries&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;5&lt;/span&gt;
          &lt;span class="na"&gt;backoff&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;initial_delay&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="nv"&gt;2&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;max_delay&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="nv"&gt;60&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;multiplier&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="nv"&gt;2&lt;/span&gt; &lt;span class="pi"&gt;}&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;make_callback&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;events.create_callback_endpoint&lt;/span&gt;
        &lt;span class="na"&gt;args&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;http_callback_method&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="nv"&gt;POST&lt;/span&gt; &lt;span class="pi"&gt;}&lt;/span&gt;
        &lt;span class="na"&gt;result&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;cb&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;request_payment&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;http.post&lt;/span&gt;
        &lt;span class="na"&gt;args&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;url&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;https://payments-abc123-uc.a.run.app/charge&lt;/span&gt;
          &lt;span class="na"&gt;auth&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="nv"&gt;OIDC&lt;/span&gt; &lt;span class="pi"&gt;}&lt;/span&gt;
          &lt;span class="na"&gt;body&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
            &lt;span class="na"&gt;order_id&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${order.id}&lt;/span&gt;
            &lt;span class="na"&gt;callback_url&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${cb.url}&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;await_payment&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;  &lt;span class="c1"&gt;# replaces .waitForTaskToken&lt;/span&gt;
        &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;events.await_callback&lt;/span&gt;
        &lt;span class="na"&gt;args&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;callback&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${cb}&lt;/span&gt;
          &lt;span class="na"&gt;timeout&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;3600&lt;/span&gt;
        &lt;span class="na"&gt;result&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;payment&lt;/span&gt;
    &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;done&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="na"&gt;return&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;${payment.http_request.body}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Step Functions errors such as &lt;code&gt;States.Timeout&lt;/code&gt; and &lt;code&gt;Lambda.ServiceException&lt;/code&gt; don't exist on the other side. Every &lt;code&gt;Retry&lt;/code&gt; and &lt;code&gt;Catch&lt;/code&gt; block maps to a &lt;code&gt;try&lt;/code&gt; with a &lt;code&gt;retry&lt;/code&gt; predicate, and custom error names your Lambdas threw become HTTP status codes your services return. Write that mapping down per state before you translate; it is where behaviour quietly changes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Identity and network
&lt;/h2&gt;

&lt;p&gt;The identity model is the same idea with different names. Each Lambda execution role becomes a service account on the service, and each function URL resource policy becomes &lt;code&gt;roles/run.invoker&lt;/code&gt;. The one default to override: Cloud Run uses the Compute Engine default service account if you don't name one, and that account often has broad project rights. Create one service account per service, and one for Pub/Sub push and Cloud Scheduler to sign their OIDC tokens with.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;AWS&lt;/th&gt;
&lt;th&gt;Google Cloud&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Lambda execution role, ECS task role&lt;/td&gt;
&lt;td&gt;Service account on the service or function&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Lambda resource policy, IAM auth on a function URL&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;roles/run.invoker&lt;/code&gt; on the service&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Public function URL or API&lt;/td&gt;
&lt;td&gt;Allow unauthenticated invocations on the service&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SigV4-signed calls between services&lt;/td&gt;
&lt;td&gt;Google-signed ID tokens between services&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Secrets Manager, Parameter Store&lt;/td&gt;
&lt;td&gt;Secret Manager, mounted as a file or env var&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;During the migration, GCP services still call AWS (an S3 bucket, a DynamoDB table) and the AWS bridge still publishes to Pub/Sub. Don't solve either with long-lived keys. The bridge Lambda authenticates to Google Cloud through Workload Identity Federation with an AWS provider, and GCP services call AWS by exchanging a Google ID token for an AWS role with &lt;code&gt;AssumeRoleWithWebIdentity&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Network.&lt;/strong&gt; Lambda joined the VPC. Cloud Run uses Direct VPC egress: &lt;code&gt;--network&lt;/code&gt;, &lt;code&gt;--subnet&lt;/code&gt; and &lt;code&gt;--vpc-egress=private-ranges-only&lt;/code&gt; or &lt;code&gt;all-traffic&lt;/code&gt; [6]. Two numbers decide the subnet size. Services use about 2 IP addresses per instance, and addresses are held for up to 20 minutes after scale-down, so during a deploy both revisions hold IPs [6]. Our API caps at 15 instances: 30 IPs steady, 60 during a deploy. Add the consumers and functions and a /26 (64 addresses, minus the 4 Google reserves) is tight; we'd use a /24 for the region and stop thinking about it.&lt;/p&gt;

&lt;p&gt;Direct VPC egress addresses are ephemeral [6]. The payment provider allow-lists our outbound IP, so the payments service routes &lt;code&gt;all-traffic&lt;/code&gt; through the VPC to Cloud NAT with a reserved static address. Everything else keeps &lt;code&gt;private-ranges-only&lt;/code&gt; and reaches the internet directly, which keeps NAT out of the path of services that don't need it.&lt;/p&gt;

&lt;h2&gt;
  
  
  The cutover, shifted by traffic
&lt;/h2&gt;

&lt;p&gt;No big-bang weekend. Each consumer and the API move on their own, and every step can be reversed by changing a weight back.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Deploy dark.&lt;/strong&gt; &lt;code&gt;gcloud run deploy orders-api --image IMAGE --no-traffic --tag green&lt;/code&gt; gives the new revision its own URL, &lt;code&gt;https://green---orders-api-HASH.a.run.app&lt;/code&gt;, with no production traffic [23]. Replay a day of sanitized production requests against it and diff responses against AWS.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Issue the certificate before DNS moves.&lt;/strong&gt; The Google-managed certificate for &lt;code&gt;api.shop.example&lt;/code&gt; on the load balancer needs DNS authorization, because DNS still points at AWS and HTTP validation would fail.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Shift the API with weighted DNS.&lt;/strong&gt; Route 53 weighted records for &lt;code&gt;api.shop.example&lt;/code&gt;, TTL 60 s: 1% to the Google load balancer, then 10%, 50% and 100%. Hold each step through at least one daily peak. Some resolvers ignore TTLs, so keep the AWS stack serving at weight 0 for a week after 100%.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Move consumers one at a time.&lt;/strong&gt; For each consumer: create its Pub/Sub subscription first as a pull subscription with no endpoint, so it starts retaining bridged messages. Then, in one change, disable the Lambda event source mapping and switch the subscription to push. Messages from the overlap window arrive twice; the &lt;code&gt;processed_events&lt;/code&gt; table absorbs them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Move the workflow last.&lt;/strong&gt; New orders start on Workflows from the moment the API at 100% calls it. In-flight Step Functions executions finish on AWS; with payment waits measured in minutes, that drains in hours.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cut the bridge, then clean up.&lt;/strong&gt; When the AWS queues have been empty for a full week, delete the bridge, the rules and the functions. Buy a Cloud Run committed use discount only after a month of real usage.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;What we'd watch at each step, side by side. The gates are our choices for this scenario; set your own before you start, not during.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Signal&lt;/th&gt;
&lt;th&gt;AWS metric&lt;/th&gt;
&lt;th&gt;Google Cloud metric&lt;/th&gt;
&lt;th&gt;Gate to take the next step&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Latency per route&lt;/td&gt;
&lt;td&gt;API Gateway &lt;code&gt;Latency&lt;/code&gt; p99&lt;/td&gt;
&lt;td&gt;Cloud Run &lt;code&gt;request_latencies&lt;/code&gt; p99&lt;/td&gt;
&lt;td&gt;GCP p99 within 10% of AWS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Errors&lt;/td&gt;
&lt;td&gt;API Gateway &lt;code&gt;5xx&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Cloud Run &lt;code&gt;request_count&lt;/code&gt; where class is 5xx&lt;/td&gt;
&lt;td&gt;Rate no higher than AWS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Queue lag&lt;/td&gt;
&lt;td&gt;SQS &lt;code&gt;ApproximateAgeOfOldestMessage&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Pub/Sub &lt;code&gt;subscription/oldest_unacked_message_age&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Under 60 s at peak&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dead letters&lt;/td&gt;
&lt;td&gt;Messages in the DLQ&lt;/td&gt;
&lt;td&gt;Messages published to the dead-letter topic&lt;/td&gt;
&lt;td&gt;Zero new ones that aren't explained&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Database&lt;/td&gt;
&lt;td&gt;Connections from Lambda&lt;/td&gt;
&lt;td&gt;Cloud SQL &lt;code&gt;num_backends&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Below 80% of &lt;code&gt;max_connections&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Duplicates&lt;/td&gt;
&lt;td&gt;n/a&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;processed_events&lt;/code&gt; conflict count&lt;/td&gt;
&lt;td&gt;No jump after a step&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cost&lt;/td&gt;
&lt;td&gt;Cost Explorer, per service&lt;/td&gt;
&lt;td&gt;Billing export, per service&lt;/td&gt;
&lt;td&gt;Cost per million requests within the model above&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;There are no servers to copy in a serverless move. The work is in the defaults: concurrency, ack deadlines, event shapes, retries, payload limits and identity. Decide each one on purpose, with numbers, and the rest is typing.&lt;/p&gt;

&lt;h2&gt;
  
  
  Common questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is the Lambda equivalent in GCP?
&lt;/h3&gt;

&lt;p&gt;Cloud Run functions for small, event-driven code, and Cloud Run services for containers. Both run on Cloud Run and both scale to zero. The biggest difference is that one Cloud Run instance handles many requests at once, which changes both the bill and what your code must be safe against.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is Cloud Run cheaper than Lambda?
&lt;/h3&gt;

&lt;p&gt;For I/O-bound APIs that can run many requests per instance, usually yes: in the worked example above, $960 a month became $156 to $326. For CPU-bound work at concurrency 1, it is about the same. The saving disappears if each instance averages little more than one request in flight.&lt;/p&gt;

&lt;h3&gt;
  
  
  What replaces SQS on GCP?
&lt;/h3&gt;

&lt;p&gt;Pub/Sub subscriptions for most queues, and Cloud Tasks when you need to rate-limit calls to a service or schedule a single task for later. Plan for one message per push request, an ack deadline of at most 600 seconds, and a dead-letter topic that needs IAM grants to work.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is there a Step Functions equivalent in GCP?
&lt;/h3&gt;

&lt;p&gt;Workflows. It covers steps, retries, choices, waits, parallel branches and callbacks, written in YAML. Each state machine is rewritten by hand, and large fan-outs, large payloads and Express workflows need a different design.&lt;/p&gt;

&lt;h3&gt;
  
  
  Do I need API Gateway on GCP?
&lt;/h3&gt;

&lt;p&gt;Often not. Cloud Run services already have HTTPS addresses and IAM checks, and JWT validation fits in middleware. Use Google's API Gateway when you want API keys or JWT checks driven by an OpenAPI spec, and Apigee when you need quotas, monetization or a partner portal.&lt;/p&gt;

&lt;h2&gt;
  
  
  How MigrateX handles this
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" alt="MigrateX" width="799" height="293"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;MigrateX is our platform and service for moving software, data and infrastructure from one technology to another. Automation does the repetitive work; experienced engineers make the decisions this post walks through.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Assessment.&lt;/strong&gt; We inventory every function, container service, API, event rule, queue, topic, schedule and state machine, with triggers, timeouts, roles, batch settings and the hidden ties to AWS, like SDK calls and ARNs in config. We flag code that is unsafe at concurrency above one before anything moves.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Model.&lt;/strong&gt; We build the cost comparison above from your own CloudWatch and billing data, per service, including the billing mode and concurrency each one should run at, so the expected saving is a number you can check.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Migration.&lt;/strong&gt; Automation rewrites entry points, turns Lambda, API Gateway and ECS Terraform into Cloud Run, and maps rules and queues to Pub/Sub and Eventarc. Our engineers handle shared state, event shapes, idempotency keys and the Step Functions rewrites.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cutover.&lt;/strong&gt; Each service runs on both clouds with the gates agreed up front. Traffic moves by weight, and every step can be reversed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Handover.&lt;/strong&gt; We turn AWS off service by service, size commitments on real usage, and leave your team owning services they understand.&lt;/li&gt;
&lt;/ol&gt;

&lt;blockquote&gt;
&lt;p&gt;Planning a move from AWS to GCP? Tell us about your setup through &lt;a href="https://cobuildx.ai/contact" rel="noopener noreferrer"&gt;Contact Us&lt;/a&gt;, and we'll start with a free conversation about where the work is likely to be.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Google Cloud
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Function timeout&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/functions/docs/configuring/timeout" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/functions/docs/configuring/timeout&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Run concurrency&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/run/docs/about-concurrency" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/run/docs/about-concurrency&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Run billing settings&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/run/docs/configuring/billing-settings" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/run/docs/configuring/billing-settings&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Run request timeout&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/run/docs/configuring/request-timeout" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/run/docs/configuring/request-timeout&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Run jobs&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/run/docs/create-jobs" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/run/docs/create-jobs&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Direct VPC egress&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/run/docs/configuring/vpc-direct-vpc" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/run/docs/configuring/vpc-direct-vpc&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Eventarc overview&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/eventarc/docs/overview" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/eventarc/docs/overview&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Push subscriptions&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/pubsub/docs/push" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/pubsub/docs/push&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Subscription properties&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/pubsub/docs/subscription-properties" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/pubsub/docs/subscription-properties&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Run pricing&lt;/em&gt;. &lt;a href="https://cloud.google.com/run/pricing" rel="noopener noreferrer"&gt;https://cloud.google.com/run/pricing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Handle message failures (dead-letter topics)&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/pubsub/docs/handling-failures" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/pubsub/docs/handling-failures&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Exactly-once delivery&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/pubsub/docs/exactly-once-delivery" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/pubsub/docs/exactly-once-delivery&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  AWS
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;AWS. &lt;em&gt;Lambda pricing&lt;/em&gt;. &lt;a href="https://aws.amazon.com/lambda/pricing/" rel="noopener noreferrer"&gt;https://aws.amazon.com/lambda/pricing/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;API Gateway pricing&lt;/em&gt;. &lt;a href="https://aws.amazon.com/api-gateway/pricing/" rel="noopener noreferrer"&gt;https://aws.amazon.com/api-gateway/pricing/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon SQS visibility timeout&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Creating and configuring an Amazon SQS event source mapping&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-configure.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-configure.html&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Filters, workflows and traffic
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Filter messages from a subscription&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/pubsub/docs/subscription-message-filter" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/pubsub/docs/subscription-message-filter&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Step Functions service quotas&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/step-functions/latest/dg/service-quotas.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/step-functions/latest/dg/service-quotas.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Workflows quotas and limits&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/workflows/quotas" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/workflows/quotas&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Wait using callbacks (Workflows)&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/workflows/docs/creating-callback-endpoints" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/workflows/docs/creating-callback-endpoints&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Step Functions pricing&lt;/em&gt;. &lt;a href="https://aws.amazon.com/step-functions/pricing/" rel="noopener noreferrer"&gt;https://aws.amazon.com/step-functions/pricing/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Workflows pricing&lt;/em&gt;. &lt;a href="https://cloud.google.com/workflows/pricing" rel="noopener noreferrer"&gt;https://cloud.google.com/workflows/pricing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Rollbacks, gradual rollouts and traffic migration&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/run/docs/rollouts-rollbacks-traffic-migration" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/run/docs/rollouts-rollbacks-traffic-migration&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Free data transfer out to internet when moving out of AWS&lt;/em&gt;. &lt;a href="https://aws.amazon.com/blogs/aws/free-data-transfer-out-to-internet-when-moving-out-of-aws/" rel="noopener noreferrer"&gt;https://aws.amazon.com/blogs/aws/free-data-transfer-out-to-internet-when-moving-out-of-aws/&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;CobuildX helps teams migrate legacy applications and cloud infrastructure with &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;MigrateX&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-serverless" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>aws</category>
      <category>googlecloud</category>
      <category>serverless</category>
      <category>cloud</category>
    </item>
    <item>
      <title>Moving Big Data from AWS to GCP: Redshift, EMR and Glue</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Thu, 05 Nov 2026 09:21:45 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/moving-big-data-from-aws-to-gcp-redshift-emr-and-glue-4lg9</link>
      <guid>https://dev.to/cobuildx-ai/moving-big-data-from-aws-to-gcp-redshift-emr-and-glue-4lg9</guid>
      <description>&lt;p&gt;&lt;em&gt;A worked migration of a Redshift, dbt, Glue, Kinesis and MWAA platform to Google Cloud: BigQuery on-demand versus slots with real cost math, the SQL that translates cleanly and still returns different results, Kinesis versus Pub/Sub semantics, and a parallel-run method that proves finance's numbers match.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Finance closes the books every month from dashboards that read a Redshift cluster. A dbt project builds those numbers overnight from Glue jobs, a Kinesis stream and a few dozen MWAA DAGs. Leadership has signed a Google Cloud commit, and the data platform is the biggest line on the AWS bill. The question is not which GCP service replaces Redshift. That answer takes a minute. The question is how you move it without a single revenue figure changing, and without a bill that is bigger than the one you left.&lt;/p&gt;

&lt;p&gt;This post works through that move on one representative platform. It is an illustrative workload, not a customer, but every assumption is stated so you can swap in your own numbers. We make the decisions in the order they bite: the BigQuery pricing model, the storage billing model, the SQL that translates cleanly and still returns different answers, moving the bytes, the jobs and the stream, access rules, and the parallel run that proves the numbers match. Prices are list prices as of November 2026: AWS in us-east-1, Google Cloud in us-central1 (Iowa).&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;This guide covers big data.&lt;/strong&gt; For EC2, EKS and GPUs, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-compute-options" rel="noopener noreferrer"&gt;moving compute from AWS to GCP&lt;/a&gt;. For Lambda, Fargate and EventBridge, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-serverless" rel="noopener noreferrer"&gt;moving serverless from AWS to GCP&lt;/a&gt;. For S3, EBS and EFS, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-storage" rel="noopener noreferrer"&gt;moving storage from AWS to GCP&lt;/a&gt;. Going the other way? Read &lt;a href="https://cobuildx.ai/blog/gcp-to-aws-big-data" rel="noopener noreferrer"&gt;moving big data from GCP to AWS&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  The platform we are moving
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Component&lt;/th&gt;
&lt;th&gt;Today on AWS&lt;/th&gt;
&lt;th&gt;Assumption that matters&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Warehouse&lt;/td&gt;
&lt;td&gt;Redshift, 4 x ra3.4xlarge, on-demand&lt;/td&gt;
&lt;td&gt;28 TB in Redshift Managed Storage (compressed), about 95 TiB uncompressed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Transforms&lt;/td&gt;
&lt;td&gt;dbt project, 310 models, nightly build plus hourly incrementals&lt;/td&gt;
&lt;td&gt;12 models are full-refresh tables totalling 2 TiB compressed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Readers&lt;/td&gt;
&lt;td&gt;Finance and ops dashboards, 30 analysts writing ad hoc SQL&lt;/td&gt;
&lt;td&gt;Finance reports by &lt;code&gt;America/New_York&lt;/code&gt; business day&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ETL&lt;/td&gt;
&lt;td&gt;46 Glue jobs and crawlers, 1 nightly EMR job&lt;/td&gt;
&lt;td&gt;Most Glue jobs are SQL wearing a Spark costume (see below)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Stream&lt;/td&gt;
&lt;td&gt;Kinesis Data Streams, 8 provisioned shards, Firehose to S3&lt;/td&gt;
&lt;td&gt;2,500 events/s average, 5,000/s peak, 1.2 KB per event&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Orchestration&lt;/td&gt;
&lt;td&gt;MWAA, 38 DAGs&lt;/td&gt;
&lt;td&gt;Every DAG touches at least one AWS operator&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Data lake&lt;/td&gt;
&lt;td&gt;S3, Parquet, governed by Lake Formation&lt;/td&gt;
&lt;td&gt;180 TB, row filters on region for regional finance teams&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Compute on the warehouse is the anchor cost: 4 nodes x $3.26/hour x 730 hours is &lt;strong&gt;$9,519 a month&lt;/strong&gt;, plus 28,000 GB of managed storage at $0.024/GB-month, another &lt;strong&gt;$672&lt;/strong&gt;. If you hold reserved nodes, use your effective rate instead, and remember the reservation keeps billing after you leave. Plan the cutover around its end date if you can.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where each piece lands
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4w02k4zglgbzejyu2724.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4w02k4zglgbzejyu2724.png" alt="Big data service map from AWS to Google Cloud: Redshift and Athena to BigQuery, EMR to Dataproc or serverless Spark, Glue ETL to serverless Spark or Dataflow, Glue Catalog and Lake Formation to Dataplex and BigLake, Kinesis and MSK to Pub/Sub or Managed Kafka, and MWAA to Cloud Composer, with what to watch for on each"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The mapping is the easy part, so we keep it short. What matters is the condition under which you would pick the other option:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;AWS&lt;/th&gt;
&lt;th&gt;Default target&lt;/th&gt;
&lt;th&gt;Pick the alternative when&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Redshift, Athena&lt;/td&gt;
&lt;td&gt;BigQuery&lt;/td&gt;
&lt;td&gt;Rarely. Athena-style queries on files become BigLake tables over Cloud Storage&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EMR, Glue Spark&lt;/td&gt;
&lt;td&gt;Serverless Spark (Managed Service for Apache Spark, formerly Dataproc)&lt;/td&gt;
&lt;td&gt;Use a Dataproc cluster if the job needs custom OS packages or a long-lived cache&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Glue SQL-shaped jobs&lt;/td&gt;
&lt;td&gt;dbt models in BigQuery&lt;/td&gt;
&lt;td&gt;Keep Spark only if the job reads files BigQuery can't, or runs heavy UDFs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Glue Catalog, Lake Formation&lt;/td&gt;
&lt;td&gt;Dataplex, BigLake, BigQuery IAM&lt;/td&gt;
&lt;td&gt;No real alternative; there is no converter, so grants get rebuilt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kinesis Data Streams&lt;/td&gt;
&lt;td&gt;Pub/Sub&lt;/td&gt;
&lt;td&gt;Use Managed Service for Apache Kafka if consumers need replay beyond 31 days or Kafka semantics&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MSK&lt;/td&gt;
&lt;td&gt;Managed Service for Apache Kafka&lt;/td&gt;
&lt;td&gt;Pub/Sub, if the only reason you ran Kafka was to have a queue&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Firehose&lt;/td&gt;
&lt;td&gt;Pub/Sub BigQuery or Cloud Storage subscription&lt;/td&gt;
&lt;td&gt;Dataflow, if records need transformation in flight&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MWAA&lt;/td&gt;
&lt;td&gt;Cloud Composer 3&lt;/td&gt;
&lt;td&gt;Workflows, for a handful of linear pipelines that don't justify an Airflow environment&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Decision 1: on-demand or slots
&lt;/h2&gt;

&lt;p&gt;BigQuery bills compute one of two ways. On-demand charges &lt;strong&gt;$6.25 per TiB&lt;/strong&gt; of data read, with the first TiB each month free. Editions charge per slot-hour: &lt;strong&gt;$0.04&lt;/strong&gt; Standard, &lt;strong&gt;$0.06&lt;/strong&gt; Enterprise, &lt;strong&gt;$0.10&lt;/strong&gt; Enterprise Plus, pay as you go, with autoscaling in multiples of 50 slots and a one-minute minimum per scale-up. On-demand punishes scanning. Editions punish compute. The right answer depends on how many slot-hours each workload burns per TiB it reads, and you can't know that from Redshift.&lt;/p&gt;

&lt;p&gt;Redshift's own scan statistics don't translate: it reads compressed blocks across slices, while BigQuery bills the uncompressed size of the columns a query touches. The only honest profile is one taken on BigQuery. Load a representative month, replay the dbt build and a sample of dashboard and ad hoc queries, then read the job metadata:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="c1"&gt;-- Slot-hours per TiB, by workload label, for the replay window&lt;/span&gt;
&lt;span class="k"&gt;SELECT&lt;/span&gt;
  &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;SELECT&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="k"&gt;FROM&lt;/span&gt; &lt;span class="k"&gt;UNNEST&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;labels&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;WHERE&lt;/span&gt; &lt;span class="k"&gt;key&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s1"&gt;'workload'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;workload&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="k"&gt;SUM&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;total_bytes_billed&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;POW&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1024&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;              &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;tib_billed&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="k"&gt;SUM&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;total_slot_ms&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="mi"&gt;3600&lt;/span&gt;                     &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;slot_hours&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;SAFE_DIVIDE&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;SUM&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;total_slot_ms&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="mi"&gt;3600&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
              &lt;span class="k"&gt;SUM&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;total_bytes_billed&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;POW&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1024&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;slot_hours_per_tib&lt;/span&gt;
&lt;span class="k"&gt;FROM&lt;/span&gt; &lt;span class="nv"&gt;`region-us-central1`&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;INFORMATION_SCHEMA&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;JOBS&lt;/span&gt;
&lt;span class="k"&gt;WHERE&lt;/span&gt; &lt;span class="n"&gt;creation_time&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="n"&gt;TIMESTAMP_SUB&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;CURRENT_TIMESTAMP&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="n"&gt;INTERVAL&lt;/span&gt; &lt;span class="mi"&gt;30&lt;/span&gt; &lt;span class="k"&gt;DAY&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
  &lt;span class="k"&gt;AND&lt;/span&gt; &lt;span class="n"&gt;job_type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s1"&gt;'QUERY'&lt;/span&gt; &lt;span class="k"&gt;AND&lt;/span&gt; &lt;span class="k"&gt;state&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s1"&gt;'DONE'&lt;/span&gt;
&lt;span class="k"&gt;GROUP&lt;/span&gt; &lt;span class="k"&gt;BY&lt;/span&gt; &lt;span class="n"&gt;workload&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Label jobs before you replay (dbt supports &lt;code&gt;query_comment&lt;/code&gt; and job labels; BI tools can set labels on their service account's jobs). Here is the profile for our representative workload, with one more number you have to estimate: the &lt;strong&gt;autoscale overhead&lt;/strong&gt;, the ratio of slot-hours billed to slot-hours used. Long, steady jobs keep the autoscaler busy and waste little. Bursty small queries pay the one-minute minimum and the 50-slot rounding over and over. Measure yours from &lt;code&gt;INFORMATION_SCHEMA.RESERVATIONS_TIMELINE&lt;/code&gt; once a test reservation exists.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Workload&lt;/th&gt;
&lt;th&gt;TiB billed/month&lt;/th&gt;
&lt;th&gt;Slot-hours used&lt;/th&gt;
&lt;th&gt;Slot-h per TiB&lt;/th&gt;
&lt;th&gt;Autoscale overhead&lt;/th&gt;
&lt;th&gt;On-demand&lt;/th&gt;
&lt;th&gt;Enterprise (pay as you go)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;dbt build&lt;/td&gt;
&lt;td&gt;640&lt;/td&gt;
&lt;td&gt;22,400&lt;/td&gt;
&lt;td&gt;35&lt;/td&gt;
&lt;td&gt;1.3x&lt;/td&gt;
&lt;td&gt;$4,000&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;$1,747&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dashboards&lt;/td&gt;
&lt;td&gt;85&lt;/td&gt;
&lt;td&gt;2,125&lt;/td&gt;
&lt;td&gt;25&lt;/td&gt;
&lt;td&gt;2.0x&lt;/td&gt;
&lt;td&gt;$531&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;$255&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ad hoc SQL&lt;/td&gt;
&lt;td&gt;160&lt;/td&gt;
&lt;td&gt;9,600&lt;/td&gt;
&lt;td&gt;60&lt;/td&gt;
&lt;td&gt;2.5x&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;$1,000&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$1,440&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The break-even is simple. At $6.25 per TiB against $0.06 per slot-hour, editions win when a workload burns fewer than &lt;strong&gt;104 billed slot-hours per TiB&lt;/strong&gt; (used slot-hours times overhead). dbt sits at 45.5, dashboards at 50, so both belong on a reservation. Ad hoc lands at 150: analysts write window functions over joins of small tables, which is compute-heavy and scan-light, and the bursts waste slots. Ad hoc stays on-demand.&lt;/p&gt;

&lt;p&gt;Reservations are assigned per project, folder or organization, so the decision becomes a project layout: a &lt;code&gt;transform&lt;/code&gt; project and a &lt;code&gt;bi&lt;/code&gt; project assigned to an Enterprise reservation with a baseline of zero and a max of 1,000 slots, and an &lt;code&gt;analytics&lt;/code&gt; project left on on-demand. Total compute: &lt;strong&gt;about $3,000 a month&lt;/strong&gt;, against $5,525 if everything ran on-demand and $3,442 if everything ran on Enterprise.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why not Standard edition, or a commitment?
&lt;/h3&gt;

&lt;p&gt;Standard at $0.04 looks like a free 33% cut on the dbt reservation. It isn't, for this platform. Standard edition has no fine-grained security controls, so no row-level or column-level security, and it caps a reservation at 1,600 slots. Our Lake Formation row filters become BigQuery row access policies, so the projects that read governed tables need Enterprise. A team with no fine-grained access rules should look hard at Standard.&lt;/p&gt;

&lt;p&gt;Enterprise slot commitments cost $0.048 per slot-hour for one year and $0.036 for three, but you pay for every hour of the term. 100 committed slots is $3,504 a month, double our whole dbt bill, because the build uses most of its slots for a couple of hours a night. A one-year commitment only beats pay as you go when the committed slots are busy more than about 62% of all hours (0.048 / (0.06 x 1.3)). Look at the timeline after a month of real traffic, and commit to the floor you never drop below, not the peak.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;On-demand without a cap is how a first week goes wrong.&lt;/strong&gt; Set a per-user daily custom quota on the on-demand project before analysts get access, and set &lt;code&gt;maximum_bytes_billed&lt;/code&gt; in dbt profiles and BI connections, so a missing partition filter fails instead of billing.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Decision 2: logical or physical storage billing
&lt;/h2&gt;

&lt;p&gt;BigQuery bills storage per dataset either on logical (uncompressed) bytes or on physical (compressed) bytes. In us-central1, logical costs $0.023/GiB-month active and $0.016 long-term (partitions untouched for 90 days). Physical costs $0.04 and $0.02, but with one catch: time travel and fail-safe bytes are billed separately at the active physical rate, while on logical billing they are included.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Option for 95 TiB logical (35 active, 60 long-term), 3.5:1 compression&lt;/th&gt;
&lt;th&gt;Monthly&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Everything on logical billing&lt;/td&gt;
&lt;td&gt;$824 + $983 = &lt;strong&gt;$1,807&lt;/strong&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Everything on physical billing, ignoring time travel&lt;/td&gt;
&lt;td&gt;$410 + $348 = $758&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Physical, plus time travel on 12 full-refresh models (2 TiB rewritten nightly, 7 days time travel + 7 days fail-safe = 28 TiB)&lt;/td&gt;
&lt;td&gt;$758 + $1,147 = &lt;strong&gt;$1,905&lt;/strong&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Physical for history datasets, full-refresh models in a logical-billed dataset&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;about $920&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Physical billing wins whenever compression beats the price ratio (1.74x for active, 1.25x for long-term) and tables are append-mostly. A dbt project full of &lt;code&gt;materialized='table'&lt;/code&gt; models is the opposite: every nightly rebuild leaves the old table in time travel and then fail-safe for 14 days. Cutting the time travel window to its 2-day minimum still leaves 9 days of copies. Put churn-heavy models in their own dataset on logical billing, or make them incremental, and the decision flips back.&lt;/p&gt;

&lt;h2&gt;
  
  
  SQL that translates cleanly and still returns different numbers
&lt;/h2&gt;

&lt;p&gt;The BigQuery batch SQL translator converts Redshift SQL in bulk and flags what it can't handle. The dangerous cases are the ones it doesn't flag, because the query runs on both engines and returns a plausible number. These are the ones we would grep for before the first parallel run:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Expression&lt;/th&gt;
&lt;th&gt;Redshift returns&lt;/th&gt;
&lt;th&gt;BigQuery returns&lt;/th&gt;
&lt;th&gt;Fix&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;refunds / orders&lt;/code&gt; (both integers)&lt;/td&gt;
&lt;td&gt;Integer division: 31 / 1000 = 0&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;/&lt;/code&gt; always returns FLOAT64: 0.031&lt;/td&gt;
&lt;td&gt;Decide which one the dashboard meant. Use &lt;code&gt;DIV()&lt;/code&gt; to keep integer semantics, or &lt;code&gt;SAFE_DIVIDE&lt;/code&gt; with an explicit cast&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;AVG(quantity)&lt;/code&gt; on an integer column&lt;/td&gt;
&lt;td&gt;BIGINT, fraction dropped: 2&lt;/td&gt;
&lt;td&gt;FLOAT64: 2.47&lt;/td&gt;
&lt;td&gt;Same: decide, then cast explicitly in the model&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;DATE_TRUNC('week', ts)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Monday of the week&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;WEEK&lt;/code&gt; starts on Sunday&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;DATE_TRUNC(d, WEEK(MONDAY))&lt;/code&gt; or &lt;code&gt;ISOWEEK&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;WHERE sku = 'AB12'&lt;/code&gt; on &lt;code&gt;'AB12  '&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Match: trailing spaces are ignored in comparisons&lt;/td&gt;
&lt;td&gt;No match&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;RTRIM&lt;/code&gt; at load time, then compare&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;A naive local-time &lt;code&gt;TIMESTAMP&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Wall-clock time, no zone&lt;/td&gt;
&lt;td&gt;An instant BigQuery assumes is UTC, off by 4 to 5 hours&lt;/td&gt;
&lt;td&gt;Load as &lt;code&gt;DATETIME&lt;/code&gt;, or convert with the source time zone (below)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;NULL vs &lt;code&gt;''&lt;/code&gt; after a text &lt;code&gt;UNLOAD&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Two different values&lt;/td&gt;
&lt;td&gt;Indistinguishable: default &lt;code&gt;UNLOAD&lt;/code&gt; writes NULL as an empty field&lt;/td&gt;
&lt;td&gt;Unload to Parquet, which keeps real NULLs&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The trailing-space row deserves a second look because it fails on joins, not filters. If a CRM export pads merchant codes, Redshift joins &lt;code&gt;'ACME '&lt;/code&gt; to &lt;code&gt;'ACME'&lt;/code&gt; and BigQuery drops the row. Revenue by merchant falls by exactly the padded merchants' share, which looks like a data-loading gap rather than a semantic one.&lt;/p&gt;

&lt;h3&gt;
  
  
  The timestamp that moves revenue between days
&lt;/h3&gt;

&lt;p&gt;Redshift &lt;code&gt;TIMESTAMP&lt;/code&gt; has no time zone and ignores any zone in input strings. If the order service wrote New York wall-clock time into &lt;code&gt;order_ts&lt;/code&gt;, Redshift has been storing local time all along. BigQuery &lt;code&gt;TIMESTAMP&lt;/code&gt; is an absolute instant, and a value loaded without a zone is taken as UTC. Load the column as-is and BigQuery stores 9 p.m. New York time as 9 p.m. UTC, four or five hours before the real instant. Nothing breaks until something does the correct thing: a model that calls &lt;code&gt;DATE(order_ts, 'America/New_York')&lt;/code&gt;, a BI tool that converts to the viewer's time zone, or new events from the stream that carry true UTC. Then orders placed between midnight and 4 a.m. Eastern (5 a.m. in winter) land on the previous business day, and history and new data mean different things in the same column. Monthly totals barely move. Daily revenue does, and month-end shifts by a few hours of sales.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="c1"&gt;-- Interpret the stored wall-clock value in its real zone, once, in staging&lt;/span&gt;
&lt;span class="k"&gt;SELECT&lt;/span&gt;
  &lt;span class="n"&gt;order_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nb"&gt;TIMESTAMP&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;DATETIME&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order_ts_raw&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="s1"&gt;'America/New_York'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;order_ts&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nb"&gt;DATE&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;TIMESTAMP&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;DATETIME&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order_ts_raw&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="s1"&gt;'America/New_York'&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
       &lt;span class="s1"&gt;'America/New_York'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                             &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;business_date&lt;/span&gt;
&lt;span class="k"&gt;FROM&lt;/span&gt; &lt;span class="n"&gt;staging&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;orders_raw&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then partition on &lt;code&gt;business_date&lt;/code&gt;, not on the UTC date, so a finance query for one business day prunes to one partition instead of two.&lt;/p&gt;

&lt;h3&gt;
  
  
  DISTKEY and SORTKEY become partitioning and clustering
&lt;/h3&gt;

&lt;p&gt;Don't translate the keys mechanically. A Redshift &lt;code&gt;DISTKEY&lt;/code&gt; exists to co-locate join rows on the same slice. BigQuery has no slices to co-locate on, so the distribution key has no direct heir. Pick partitioning from the date filter almost every query uses, and up to four clustering columns from the next most selective filters. Two limits shape the choice: 10,000 partitions per table (daily partitions last 27 years, hourly ones about 14 months), and clustering pruning that the dry-run estimate can't see, so on-demand estimates on clustered tables are an upper bound.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight jinja"&gt;&lt;code&gt;-- dbt on Redshift
&lt;span class="cp"&gt;{{&lt;/span&gt; &lt;span class="nv"&gt;config&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;materialized&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'incremental'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;unique_key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'order_id'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
          &lt;span class="nv"&gt;dist&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'customer_id'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;sort&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'order_ts'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="cp"&gt;}}&lt;/span&gt;

-- dbt on BigQuery
&lt;span class="cp"&gt;{{&lt;/span&gt; &lt;span class="nv"&gt;config&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="nv"&gt;materialized&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'incremental'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nv"&gt;incremental_strategy&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s1"&gt;'insert_overwrite'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nv"&gt;partition_by&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="err"&gt;{&lt;/span&gt;&lt;span class="s1"&gt;'field'&lt;/span&gt;&lt;span class="err"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'business_date'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'data_type'&lt;/span&gt;&lt;span class="err"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'date'&lt;/span&gt;&lt;span class="err"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nv"&gt;cluster_by&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s1"&gt;'merchant_id'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;'region'&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt;
    &lt;span class="nv"&gt;require_partition_filter&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;true&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="cp"&gt;}}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Note the strategy change. A &lt;code&gt;merge&lt;/code&gt; incremental with only a &lt;code&gt;unique_key&lt;/code&gt; scans the whole target table to find matches. On a 20 TiB fact table that is $125 per run on-demand, or a large slot bill on a reservation, every hour. &lt;code&gt;insert_overwrite&lt;/code&gt; replaces only the partitions the new batch touches. Use &lt;code&gt;merge&lt;/code&gt; only with &lt;code&gt;incremental_predicates&lt;/code&gt; that bound the target scan.&lt;/p&gt;

&lt;h2&gt;
  
  
  Moving the bytes
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgcjgi27gourbd5q76x1e.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgcjgi27gourbd5q76x1e.png" alt="Moving data from AWS to GCP: Redshift tables go through the BigQuery Data Transfer Service, which unloads to S3 and loads into BigQuery; S3 data lake files go through Storage Transfer Service into Cloud Storage and are read as BigLake or Iceberg tables; then both sides run in parallel and results are compared before reports switch"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The BigQuery Data Transfer Service has a Redshift connector: migration agents run &lt;code&gt;UNLOAD&lt;/code&gt; to an S3 staging bucket, and the service loads the files into BigQuery with the schema. It is the right tool for the long tail of dimension and small fact tables. It is the wrong tool for the big ones, for four reasons in Google's own documentation:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;It stages CSV.&lt;/strong&gt; Text unloads collapse NULL and empty string, and files containing an ASCII 0 character can't be loaded at all. The documented workaround is your own Parquet unload.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;15 TB per load job per table.&lt;/strong&gt; Exported text is larger than Redshift's compressed size, so a table Redshift reports at 6 TB can cross the line. Google asks you to contact Customer Care above 15 TB.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Re-runs append.&lt;/strong&gt; Running a transfer twice for the same table duplicates rows. Pair it with a truncate step, or use it once for history.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;S3 to BigQuery goes over the public internet&lt;/strong&gt;, and the cluster's security group must allow Google's IP ranges on port 5439.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For the big fact tables we unload ourselves, month by month, to Parquet, copy with Storage Transfer Service, and load from Cloud Storage:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;-- Redshift: one month of orders, Parquet keeps NULLs and types
UNLOAD ('SELECT * FROM sales.orders
         WHERE order_ts &amp;gt;= ''2026-09-01'' AND order_ts &amp;lt; ''2026-10-01''')
TO 's3://acme-unload/orders/2026-09/'
IAM_ROLE default
FORMAT AS PARQUET
MAXFILESIZE 1 GB;

# GCP: load the copied month into a staging table
bq load --source_format=PARQUET \
  staging.orders_raw 'gs://acme-unload/orders/2026-09/*'
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Time it before you promise a date. The lake plus the unloaded warehouse is about 220 TB here. At a sustained 5 Gbps, one TB takes about 27 minutes and the whole set about 98 hours; at 1 Gbps it is three weeks. Test throughput on a real 1 TB prefix first. On egress fees: AWS waives data transfer out to the internet for customers moving all their data off AWS, through a request to AWS Support, and eligible customers outside the EU get 180 days to finish. Get the approval before the first large copy, not after.&lt;/p&gt;

&lt;h2&gt;
  
  
  Glue and EMR: sort jobs by what they actually do
&lt;/h2&gt;

&lt;p&gt;Glue has no single home on GCP, so don't port it job by job. Read each job and classify it. On our 46 Glue jobs and crawlers, the split looks like this:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;What the job really does&lt;/th&gt;
&lt;th&gt;Count&lt;/th&gt;
&lt;th&gt;Target&lt;/th&gt;
&lt;th&gt;Main work&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Reads tables, runs SQL-shaped transforms, writes Redshift&lt;/td&gt;
&lt;td&gt;24&lt;/td&gt;
&lt;td&gt;dbt models in BigQuery&lt;/td&gt;
&lt;td&gt;Translate Spark SQL to GoogleSQL, delete the Spark job&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Real Spark: UDFs, large shuffles over lake files&lt;/td&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;td&gt;Serverless Spark&lt;/td&gt;
&lt;td&gt;Remove &lt;code&gt;GlueContext&lt;/code&gt;, &lt;code&gt;DynamicFrame&lt;/code&gt; and bookmarks&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Glue streaming off Kinesis&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;Pub/Sub BigQuery subscription, or Dataflow&lt;/td&gt;
&lt;td&gt;Delete it if it only lands raw records&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Crawlers&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;Table definitions in Terraform, BigLake for lake files&lt;/td&gt;
&lt;td&gt;Pin schemas in code; crawler drift goes away&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Python shell jobs pulling from APIs&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;Cloud Run jobs triggered by Composer&lt;/td&gt;
&lt;td&gt;Move secrets to Secret Manager&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Half the Glue estate disappears into the dbt project, which is the cheapest outcome: one less runtime to operate. The nine real Spark jobs and the nightly EMR job move to serverless Spark with &lt;code&gt;s3://&lt;/code&gt; swapped for &lt;code&gt;gs://&lt;/code&gt; and EMRFS or S3A settings deleted, since the Cloud Storage connector is built in. Glue job bookmarks have no equivalent; replace them with a watermark table the job reads at start and writes on success, which is also easier to reset during the parallel run.&lt;/p&gt;

&lt;h2&gt;
  
  
  Kinesis to Pub/Sub: ordering, replay and the bill
&lt;/h2&gt;

&lt;p&gt;Producers port in a day. Consumers are where the semantics differ:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Kinesis Data Streams (provisioned)&lt;/th&gt;
&lt;th&gt;Pub/Sub&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Ordering&lt;/td&gt;
&lt;td&gt;Per shard; one partition key always lands on one shard&lt;/td&gt;
&lt;td&gt;Per ordering key, only if the subscription enables ordering and the key is published from one region&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Hot key limit&lt;/td&gt;
&lt;td&gt;1 MB/s or 1,000 records/s write per shard&lt;/td&gt;
&lt;td&gt;1 MBps publish per ordering key&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Consumer position&lt;/td&gt;
&lt;td&gt;Sequence-number checkpoint per shard, held by the consumer&lt;/td&gt;
&lt;td&gt;Per-message ack; deadline 10 s default, 600 s max&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;After a consumer crash&lt;/td&gt;
&lt;td&gt;Re-reads from the last checkpoint&lt;/td&gt;
&lt;td&gt;Redelivers; with ordering, every later message for that key is redelivered too, even ones already acked&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Replay window&lt;/td&gt;
&lt;td&gt;24 hours default, up to 365 days&lt;/td&gt;
&lt;td&gt;Subscription retention 7 days default, 31 days max, then seek to a timestamp&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Scaling&lt;/td&gt;
&lt;td&gt;Split and merge shards; parent shards drain before children&lt;/td&gt;
&lt;td&gt;No shards&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two consumer changes are mandatory. Any code that deduplicates on Kinesis sequence numbers needs a producer-assigned event ID in a message attribute, because Pub/Sub redelivery will hand it the same event twice and no sequence number to recognise it by. And any consumer that replays more than 31 days (a backfill job reading 90 days off the stream, say) needs a different source: a Cloud Storage subscription archiving raw events, or Kafka.&lt;/p&gt;

&lt;p&gt;Then the bill, which surprises people in the other direction. Our stream carries 2,500 events/s x 1.2 KB, about &lt;strong&gt;7.17 TiB a month&lt;/strong&gt;. Kinesis: 8 shards x 730 hours x $0.015 is $87.60, plus 6.57 billion PUT payload units at $0.014 per million, $92, so &lt;strong&gt;$180 a month&lt;/strong&gt; before Firehose. Pub/Sub bills throughput at $40 per TiB published and $40 per TiB per subscription delivered, and $50 per TiB for BigQuery subscriptions. Publish ($287), one pull subscription for the fraud service ($287) and a BigQuery subscription replacing Firehose ($359) total &lt;strong&gt;$932&lt;/strong&gt;. At steady, high throughput, Pub/Sub costs more than provisioned shards. You are paying to stop resharding and to drop the Firehose and its Glue streaming job. If that trade isn't worth $750 a month to you, price Managed Service for Apache Kafka for the same throughput before you choose.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_pubsub_topic"&lt;/span&gt; &lt;span class="s2"&gt;"orders"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;                       &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"orders"&lt;/span&gt;
  &lt;span class="nx"&gt;message_retention_duration&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"604800s"&lt;/span&gt; &lt;span class="c1"&gt;# 7 days on the topic&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_pubsub_subscription"&lt;/span&gt; &lt;span class="s2"&gt;"fraud"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;                       &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"orders-fraud"&lt;/span&gt;
  &lt;span class="nx"&gt;topic&lt;/span&gt;                      &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_pubsub_topic&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;orders&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;enable_message_ordering&lt;/span&gt;    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;   &lt;span class="c1"&gt;# producer sets ordering_key = merchant_id&lt;/span&gt;
  &lt;span class="nx"&gt;ack_deadline_seconds&lt;/span&gt;       &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;60&lt;/span&gt;
  &lt;span class="nx"&gt;retain_acked_messages&lt;/span&gt;      &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;   &lt;span class="c1"&gt;# needed to seek back after a bad deploy&lt;/span&gt;
  &lt;span class="nx"&gt;message_retention_duration&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"604800s"&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_pubsub_subscription"&lt;/span&gt; &lt;span class="s2"&gt;"orders_to_bq"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"orders-to-bigquery"&lt;/span&gt;
  &lt;span class="nx"&gt;topic&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_pubsub_topic&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;orders&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;bigquery_config&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;table&lt;/span&gt;            &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"acme-data.raw.orders_events"&lt;/span&gt;
    &lt;span class="nx"&gt;use_table_schema&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  MWAA to Composer, and the switch that moves readers
&lt;/h2&gt;

&lt;p&gt;Composer 3 offers both Airflow 2 and Airflow 3 builds. Land the 38 DAGs on the same Airflow major version MWAA runs today, and upgrade Airflow as a separate change after cutover, so an upgrade regression can't be confused with a migration one. Every &lt;code&gt;S3&lt;/code&gt;, &lt;code&gt;Redshift&lt;/code&gt;, &lt;code&gt;Glue&lt;/code&gt;, &lt;code&gt;EMR&lt;/code&gt; and &lt;code&gt;Athena&lt;/code&gt; operator becomes its &lt;code&gt;GCS&lt;/code&gt;, &lt;code&gt;BigQuery&lt;/code&gt;, &lt;code&gt;Dataproc&lt;/code&gt; or &lt;code&gt;Dataflow&lt;/code&gt; counterpart from the Google provider package, and stored AWS keys become the environment's service account.&lt;/p&gt;

&lt;p&gt;During the parallel run both orchestrators run. MWAA keeps feeding Redshift and the live dashboards; Composer runs the same pipelines into BigQuery plus a reconciliation DAG. Each reader team switches by repointing its BI connection, never by changing pipelines, so rolling a team back is a connection change too.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rebuilding Lake Formation grants
&lt;/h2&gt;

&lt;p&gt;There is no converter from Lake Formation to BigQuery. LF-tags on columns map to policy tags in a Dataplex taxonomy, and data filters on rows map to row access policies. Export every grant, rebuild it in Terraform, and treat the list as a security review: grants nobody can explain are the ones to drop.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="k"&gt;CREATE&lt;/span&gt; &lt;span class="k"&gt;ROW&lt;/span&gt; &lt;span class="k"&gt;ACCESS&lt;/span&gt; &lt;span class="n"&gt;POLICY&lt;/span&gt; &lt;span class="n"&gt;apac_finance&lt;/span&gt;
&lt;span class="k"&gt;ON&lt;/span&gt; &lt;span class="n"&gt;finance&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;revenue_daily&lt;/span&gt;
&lt;span class="k"&gt;GRANT&lt;/span&gt; &lt;span class="k"&gt;TO&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'group:finance-apac@acme.example'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;FILTER&lt;/span&gt; &lt;span class="k"&gt;USING&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;region&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s1"&gt;'APAC'&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Test it as the restricted group, not as yourself: a user with no matching policy sees zero rows rather than an error, which looks exactly like an empty table.&lt;/p&gt;

&lt;h2&gt;
  
  
  Proving the numbers: the parallel run
&lt;/h2&gt;

&lt;p&gt;Row counts alone prove almost nothing: every silent difference above keeps row counts identical. We compare in three layers, each run daily by the reconciliation DAG on both engines and written to one BigQuery table.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Shape&lt;/strong&gt;, per table per business date: row count, distinct key count, min and max timestamp, NULL count and empty-string count per nullable text column.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Content fingerprint&lt;/strong&gt;, per table per business date: the sum of a hash over a canonical form of the key and the money columns.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Metrics&lt;/strong&gt;, the 40 numbers finance actually signs off: revenue, refunds, net revenue, orders, and each ratio, by day, region and product line. Money must match to the cent. Ratios must match to the precision the dashboard shows.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The fingerprint only works if both engines build the same string. Two traps: BigQuery's &lt;code&gt;CAST(NUMERIC AS STRING)&lt;/code&gt; drops trailing zeros (&lt;code&gt;12.5&lt;/code&gt;) where Redshift keeps the scale (&lt;code&gt;12.50&lt;/code&gt;), so fingerprint money as integer cents. And sum a short hex prefix of the hash, so the total can't overflow a 64-bit integer.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="c1"&gt;-- Redshift&lt;/span&gt;
&lt;span class="k"&gt;SELECT&lt;/span&gt; &lt;span class="n"&gt;business_date&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;COUNT&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="k"&gt;SUM&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;STRTOL&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;LEFT&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;MD5&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order_id&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nb"&gt;VARCHAR&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="s1"&gt;'|'&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt;
      &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;amount&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt;&lt;span class="p"&gt;)::&lt;/span&gt;&lt;span class="nb"&gt;BIGINT&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nb"&gt;VARCHAR&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="mi"&gt;16&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;fp&lt;/span&gt;
&lt;span class="k"&gt;FROM&lt;/span&gt; &lt;span class="n"&gt;sales&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;orders&lt;/span&gt; &lt;span class="k"&gt;GROUP&lt;/span&gt; &lt;span class="k"&gt;BY&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="c1"&gt;-- BigQuery&lt;/span&gt;
&lt;span class="k"&gt;SELECT&lt;/span&gt; &lt;span class="n"&gt;business_date&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;COUNT&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="k"&gt;SUM&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;CAST&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;CONCAT&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;'0x'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;SUBSTR&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;TO_HEX&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;MD5&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;CONCAT&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
      &lt;span class="k"&gt;CAST&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order_id&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;STRING&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="s1"&gt;'|'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="k"&gt;CAST&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;CAST&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;amount&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;INT64&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;STRING&lt;/span&gt;&lt;span class="p"&gt;)))),&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;INT64&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;AS&lt;/span&gt; &lt;span class="n"&gt;fp&lt;/span&gt;
&lt;span class="k"&gt;FROM&lt;/span&gt; &lt;span class="n"&gt;sales&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;orders&lt;/span&gt; &lt;span class="k"&gt;GROUP&lt;/span&gt; &lt;span class="k"&gt;BY&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The pattern of the diff tells you which bug you have, which is the point of running three layers instead of one:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Symptom&lt;/th&gt;
&lt;th&gt;Likely cause&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Monthly totals match, daily counts shift between adjacent days&lt;/td&gt;
&lt;td&gt;Naive timestamp loaded as UTC&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Counts and fingerprints match, a ratio metric differs&lt;/td&gt;
&lt;td&gt;Integer division or integer &lt;code&gt;AVG&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Weekly metrics differ, daily ones match&lt;/td&gt;
&lt;td&gt;Week starts Sunday instead of Monday&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fewer rows after a join, base tables match&lt;/td&gt;
&lt;td&gt;Trailing spaces in a join key&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;NULL count up, empty-string count down by the same amount&lt;/td&gt;
&lt;td&gt;Text unload collapsed &lt;code&gt;''&lt;/code&gt; into NULL&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Counts match, fingerprint differs on a few dates&lt;/td&gt;
&lt;td&gt;Late-arriving updates applied on one side only; check the incremental window&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  How long to run both
&lt;/h3&gt;

&lt;p&gt;Duration is set by the calendar, not by a number of days. The run has to cover every cadence the numbers are produced on: the nightly build, the weekly reports, and at least one full &lt;strong&gt;month-end close&lt;/strong&gt;, including the adjustments finance posts in the first business days of the next month, because that is when late data and manual corrections arrive. Then require ten consecutive business days with zero unexplained diffs on the 40 signed-off metrics. An explained diff (a bug fixed on the BigQuery side, or a Redshift bug finance accepts) resets nothing but goes in a log finance signs.&lt;/p&gt;

&lt;p&gt;Price the overlap honestly. Every month of parallel running costs the full Redshift bill, about $10,200 here, on top of the new platform. That pressure is real, and it is still cheaper than restating a month of revenue. After the last team switches, pause the Redshift cluster instead of deleting it: compute stops billing, storage keeps the rollback option open until the next close passes cleanly, then take a final snapshot and delete.&lt;/p&gt;

&lt;h2&gt;
  
  
  The monthly bill, before and after
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Line&lt;/th&gt;
&lt;th&gt;AWS (us-east-1)&lt;/th&gt;
&lt;th&gt;Google Cloud (us-central1)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Warehouse compute&lt;/td&gt;
&lt;td&gt;$9,519 (4 x ra3.4xlarge)&lt;/td&gt;
&lt;td&gt;$3,002 (Enterprise for dbt and BI, on-demand for ad hoc)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Warehouse storage&lt;/td&gt;
&lt;td&gt;$672 (managed storage)&lt;/td&gt;
&lt;td&gt;about $920 (mixed physical and logical billing)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Stream&lt;/td&gt;
&lt;td&gt;$180 (Kinesis, before Firehose)&lt;/td&gt;
&lt;td&gt;$932 (Pub/Sub, including the Firehose replacement)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Total modelled&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;$10,371&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;about $4,854&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Glue, EMR, MWAA, Composer and serverless Spark are left out because their cost depends on job shapes we haven't fixed here; model them from your own job history. Two things in this table are worth more than the totals. Storage costs more on GCP, not less, because BigQuery bills uncompressed bytes unless you choose physical billing carefully. And the biggest compute saving doesn't come from BigQuery being cheaper per unit. It comes from not paying for a cluster sized for the nightly build to sit idle the other 20 hours.&lt;/p&gt;

&lt;h2&gt;
  
  
  The order we would do it in
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Inventory and label.&lt;/strong&gt; Every schema, job, DAG, stream consumer and dashboard, with owner and the metrics finance signs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Land a month and profile it.&lt;/strong&gt; Replay labelled workloads, measure slot-hours per TiB, choose the project layout and pricing model from data.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Grep for the silent six.&lt;/strong&gt; Integer division, integer &lt;code&gt;AVG&lt;/code&gt;, week truncation, padded keys, naive timestamps, text unloads.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Copy history in Parquet&lt;/strong&gt;, then feed both platforms daily.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Rebuild grants&lt;/strong&gt; and test them as the restricted groups.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Parallel run&lt;/strong&gt; through a month-end close plus ten clean business days.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Switch readers team by team&lt;/strong&gt;, pause Redshift, delete after the next clean close.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Common questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Is BigQuery cheaper than Redshift?
&lt;/h3&gt;

&lt;p&gt;For bursty workloads, usually, because you stop paying for an idle cluster. In our worked example warehouse compute drops from $9,519 to about $3,000 a month. Storage can cost more, and on-demand without quotas can cost far more. Profile slot-hours per TiB on BigQuery before deciding.&lt;/p&gt;

&lt;h3&gt;
  
  
  Should we use BigQuery on-demand or editions?
&lt;/h3&gt;

&lt;p&gt;Per workload, not per company. At list price in us-central1, Enterprise beats on-demand when a workload burns fewer than about 104 billed slot-hours per TiB it reads. Batch transforms usually do; ad hoc analysis often doesn't. Split them into separate projects.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do I migrate data from Redshift to BigQuery?
&lt;/h3&gt;

&lt;p&gt;Use the BigQuery Data Transfer Service Redshift connector for small and medium tables. For large fact tables, unload to Parquet month by month, copy with Storage Transfer Service and load from Cloud Storage, which avoids the CSV staging, the 15 TB per-load limit and duplicate rows on re-runs.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why do my numbers differ after moving from Redshift?
&lt;/h3&gt;

&lt;p&gt;The usual causes are integer division and integer &lt;code&gt;AVG&lt;/code&gt; (BigQuery returns FLOAT64), weeks starting on Sunday, trailing spaces that Redshift ignores in comparisons, naive timestamps loaded as UTC, and NULL versus empty string lost in text unloads.&lt;/p&gt;

&lt;h3&gt;
  
  
  What replaces Kinesis on Google Cloud?
&lt;/h3&gt;

&lt;p&gt;Pub/Sub for most event streams, with ordering keys in place of partition keys and idempotent consumers. If consumers replay more than 31 days back, or depend on Kafka semantics, use Managed Service for Apache Kafka.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the GCP equivalent of AWS Glue?
&lt;/h3&gt;

&lt;p&gt;There isn't one product. SQL-shaped Glue jobs become dbt or Dataform models in BigQuery, real Spark jobs move to serverless Spark, streaming jobs to Dataflow or a Pub/Sub subscription, and the Data Catalog to Dataplex and BigLake.&lt;/p&gt;

&lt;h2&gt;
  
  
  About MigrateX
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" alt="MigrateX"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;MigrateX is our platform and service for moving software, data and infrastructure from one technology to another. Automation does the repetitive work, and experienced engineers make the decisions that need judgement. On an AWS to GCP data move, that splits like this:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Assessment.&lt;/strong&gt; We inventory every warehouse schema, Athena table, EMR cluster, Glue job, stream consumer and DAG, with size, owners, and hidden AWS ties like &lt;code&gt;s3://&lt;/code&gt; paths and stored access keys, and we classify Glue jobs by what they actually do.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan.&lt;/strong&gt; With your team we profile the workload on BigQuery, choose the pricing and storage billing model per project and dataset, design partitioning and access rules, and order the waves.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Migration.&lt;/strong&gt; Automation translates Redshift SQL, flags the semantic differences that change results, rewrites Glue jobs as plain Spark, swaps Airflow operators and sets up transfers. Engineers handle data models, stream semantics, grants and cost.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Proof.&lt;/strong&gt; Both platforms run side by side with layered reconciliation, and readers switch only when the signed-off metrics match.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Handover.&lt;/strong&gt; We retire AWS jobs and clusters wave by wave, tune reservations once usage is steady, and leave your team owning a platform they understand.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;What you get along the way:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No big switch-over weekend.&lt;/strong&gt; Reports keep running while readers move one team at a time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Numbers you can trust.&lt;/strong&gt; Reconciliation at the row, fingerprint and metric level before anyone switches.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A bill you predicted.&lt;/strong&gt; Pricing and storage models chosen from a measured profile, with quotas set before the first query.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;More than one kind of move.&lt;/strong&gt; The same approach covers compute, storage and serverless, and front ends like Angular, Ember and jQuery.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;Planning a move from AWS to GCP? We'd love to hear about it. Tell us a little about your setup through &lt;a href="https://cobuildx.ai/contact" rel="noopener noreferrer"&gt;Contact Us&lt;/a&gt;, and we'll start with a free chat about where the work is likely to be.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Google Cloud
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Amazon Redshift to BigQuery migration: Overview&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/migration/redshift-overview" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/migration/redshift-overview&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Migrate schema and data from Amazon Redshift&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/migration/redshift" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/migration/redshift&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Translate SQL queries with the batch SQL translator&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/batch-sql-translator" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/batch-sql-translator&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;BigQuery pricing&lt;/em&gt;. &lt;a href="https://cloud.google.com/bigquery/pricing" rel="noopener noreferrer"&gt;https://cloud.google.com/bigquery/pricing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Understand BigQuery editions&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/editions-intro" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/editions-intro&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Introduction to slots autoscaling&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/slots-autoscaling-intro" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/slots-autoscaling-intro&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Data retention with time travel and fail-safe&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/time-travel" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/time-travel&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;BigQuery quotas and limits&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/quotas" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/quotas&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Introduction to clustered tables&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/clustered-tables" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/clustered-tables&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;GoogleSQL operators&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/operators&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;GoogleSQL timestamp functions&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/timestamp_functions" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/timestamp_functions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Pub/Sub pricing&lt;/em&gt;. &lt;a href="https://cloud.google.com/pubsub/pricing" rel="noopener noreferrer"&gt;https://cloud.google.com/pubsub/pricing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Order messages&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/pubsub/docs/ordering" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/pubsub/docs/ordering&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Subscription properties&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/pubsub/docs/subscription-properties" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/pubsub/docs/subscription-properties&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Replay and purge messages&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/pubsub/docs/replay-overview" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/pubsub/docs/replay-overview&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Composer versions&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/composer/docs/composer-versions" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/composer/docs/composer-versions&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Managed Service for Apache Spark (Dataproc)&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/managed-spark/docs/reference" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/managed-spark/docs/reference&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Google Cloud Managed Service for Apache Kafka&lt;/em&gt;. &lt;a href="https://cloud.google.com/products/managed-service-for-apache-kafka" rel="noopener noreferrer"&gt;https://cloud.google.com/products/managed-service-for-apache-kafka&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Storage Transfer Service&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/storage-transfer/docs/overview" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/storage-transfer/docs/overview&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  AWS
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon Redshift pricing&lt;/em&gt;. &lt;a href="https://aws.amazon.com/redshift/pricing/" rel="noopener noreferrer"&gt;https://aws.amazon.com/redshift/pricing/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;UNLOAD (Amazon Redshift)&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/redshift/latest/dg/r_UNLOAD.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/redshift/latest/dg/r_UNLOAD.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Computations with numeric values (Amazon Redshift)&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/redshift/latest/dg/r_numeric_computations201.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/redshift/latest/dg/r_numeric_computations201.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;AVG function (Amazon Redshift)&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/redshift/latest/dg/r_AVG.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/redshift/latest/dg/r_AVG.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;DATE_TRUNC function (Amazon Redshift)&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/redshift/latest/dg/r_DATE_TRUNC.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/redshift/latest/dg/r_DATE_TRUNC.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Character types (Amazon Redshift)&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/redshift/latest/dg/r_Character_types.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/redshift/latest/dg/r_Character_types.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Datetime types (Amazon Redshift)&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/redshift/latest/dg/r_Datetime_types.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/redshift/latest/dg/r_Datetime_types.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Kinesis Data Streams quotas and limits&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon Kinesis Data Streams pricing&lt;/em&gt;. &lt;a href="https://aws.amazon.com/kinesis/data-streams/pricing/" rel="noopener noreferrer"&gt;https://aws.amazon.com/kinesis/data-streams/pricing/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Free data transfer out to internet when moving out of AWS&lt;/em&gt;. &lt;a href="https://aws.amazon.com/blogs/aws/free-data-transfer-out-to-internet-when-moving-out-of-aws/" rel="noopener noreferrer"&gt;https://aws.amazon.com/blogs/aws/free-data-transfer-out-to-internet-when-moving-out-of-aws/&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;CobuildX helps teams migrate legacy applications and cloud infrastructure with &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;MigrateX&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-big-data" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>aws</category>
      <category>googlecloud</category>
      <category>dataengineering</category>
      <category>bigdata</category>
    </item>
    <item>
      <title>Moving Compute from AWS to GCP: VMs, Kubernetes and GPUs</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Thu, 05 Nov 2026 09:21:08 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/moving-compute-from-aws-to-gcp-vms-kubernetes-and-gpus-1ei5</link>
      <guid>https://dev.to/cobuildx-ai/moving-compute-from-aws-to-gcp-vms-kubernetes-and-gpus-1ei5</guid>
      <description>&lt;p&gt;&lt;em&gt;One representative estate, moved from AWS to Google Cloud in numbers: which machine family wins on price per request, what an expiring Savings Plan lets you move first, why Spot drain logic breaks at 30 seconds, how big the GKE pod range must be, and what to do with a model compiled for Inferentia.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;You run 40 &lt;code&gt;c6i.2xlarge&lt;/code&gt; instances behind three Auto Scaling groups, a fleet of Spot workers, an EKS cluster with about 1,400 pods and 16 &lt;code&gt;inf2.xlarge&lt;/code&gt; machines serving a ranking model. A Compute Savings Plan covers most of it and ends in March. Leadership has signed a Google Cloud commitment. What do you do first?&lt;/p&gt;

&lt;p&gt;Not the service map. EC2 to Compute Engine and EKS to GKE takes five minutes to draw. The work that decides whether the move saves money or burns a quarter sits elsewhere: which machine family actually wins once you price your real shapes, what your Savings Plan lets you move and when, whether your Spot drain logic survives a 30-second window, how big the GKE pod range must be before the cluster exists, and what happens to a model compiled for Inferentia.&lt;/p&gt;

&lt;p&gt;This post works through those decisions on one representative workload, with list prices, thresholds that flip each decision, the errors you'd hit and the checks we'd run before shifting traffic.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;This guide covers compute.&lt;/strong&gt; For Lambda, Fargate and EventBridge, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-serverless" rel="noopener noreferrer"&gt;moving serverless from AWS to GCP&lt;/a&gt;. For EBS, EFS and S3, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-storage" rel="noopener noreferrer"&gt;moving storage from AWS to GCP&lt;/a&gt;. For EMR, Glue and Redshift, see &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-big-data" rel="noopener noreferrer"&gt;moving big data from AWS to GCP&lt;/a&gt;. Going the other way? Read &lt;a href="https://cobuildx.ai/blog/gcp-to-aws-compute-options" rel="noopener noreferrer"&gt;moving compute from GCP to AWS&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  The workload we'll move
&lt;/h2&gt;

&lt;p&gt;This is an illustrative workload, not a customer. It's shaped like the estates we see most often, and every number below is an assumption you should replace with your own.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tier&lt;/th&gt;
&lt;th&gt;On AWS today (us-east-1)&lt;/th&gt;
&lt;th&gt;Measured usage&lt;/th&gt;
&lt;th&gt;Constraint&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;API&lt;/td&gt;
&lt;td&gt;3 ASGs, 40 &lt;code&gt;c6i.2xlarge&lt;/code&gt; (8 vCPU, 16 GiB) baseline, 64 at peak&lt;/td&gt;
&lt;td&gt;p95 CPU 45%, p95 memory 9 GiB&lt;/td&gt;
&lt;td&gt;p99 latency SLO of 250 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Queue workers&lt;/td&gt;
&lt;td&gt;30 Spot instances, mixed &lt;code&gt;c6i&lt;/code&gt; and &lt;code&gt;m6i&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Jobs take 20 to 70 s; drain handler waits 90 s&lt;/td&gt;
&lt;td&gt;Jobs must not be processed twice&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kubernetes&lt;/td&gt;
&lt;td&gt;EKS prod: 60 &lt;code&gt;m6i.2xlarge&lt;/code&gt; nodes via Karpenter, peaks at 140; ~1,400 pods; 35 IRSA roles&lt;/td&gt;
&lt;td&gt;Average 23 pods per node, densest nodes 41&lt;/td&gt;
&lt;td&gt;Platform team of three&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Inference&lt;/td&gt;
&lt;td&gt;16 &lt;code&gt;inf2.xlarge&lt;/code&gt; (Neuron-compiled PyTorch ranker), 4 &lt;code&gt;g6.xlarge&lt;/code&gt; (L4) for a second model&lt;/td&gt;
&lt;td&gt;Steady 24/7&lt;/td&gt;
&lt;td&gt;p99 inference under 40 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Contracts&lt;/td&gt;
&lt;td&gt;Compute Savings Plan, $30/hr commitment, ends in March&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;GCP commitment already signed&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The service map for this estate fits in one figure. Keep it as an index, then spend your time on the decisions below it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F10m3w5i969nvfezsi5xw.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F10m3w5i969nvfezsi5xw.png" alt="Compute service map from AWS to Google Cloud: EC2 to Compute Engine, Auto Scaling groups to managed instance groups, EC2 Spot to Spot VMs, EKS to GKE Standard or Autopilot, GPU instances to A and G series machines, Trainium and Inferentia to GPUs or TPUs, and AWS Batch to Batch, with what to watch for on each" width="800" height="414"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Decision 1: what the Savings Plan lets you move, and when
&lt;/h2&gt;

&lt;p&gt;Savings Plans don't move, and you pay the hourly commitment whether or not anything uses it. A Compute Savings Plan is flexible on the AWS side, though: it applies to EC2 in any family, size or region, and to Fargate and Lambda [17]. So the question isn't "when does the plan end". It's "how much eligible usage can I remove before the commitment is left uncovered".&lt;/p&gt;

&lt;p&gt;Pull two numbers from Cost Explorer: the hourly commitment, and the eligible usage per hour priced at Savings Plan rates. With our illustrative fleet at us-east-1 On-Demand list prices (November 2026) [18] and an assumed 25% blended Savings Plan discount:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tier&lt;/th&gt;
&lt;th&gt;On-Demand $/hr&lt;/th&gt;
&lt;th&gt;At SP rates (assumed −25%)&lt;/th&gt;
&lt;th&gt;Effect of moving it early&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Spot workers&lt;/td&gt;
&lt;td&gt;n/a&lt;/td&gt;
&lt;td&gt;n/a&lt;/td&gt;
&lt;td&gt;None. Savings Plans don't cover Spot, so move these first&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;API (40 × $0.34, plus peak hours averaged in)&lt;/td&gt;
&lt;td&gt;~$17.00&lt;/td&gt;
&lt;td&gt;~$12.75&lt;/td&gt;
&lt;td&gt;Fits inside the headroom&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EKS prod (60 × &lt;code&gt;m6i.2xlarge&lt;/code&gt; at $0.384, plus staging)&lt;/td&gt;
&lt;td&gt;~$26.90&lt;/td&gt;
&lt;td&gt;~$20.20&lt;/td&gt;
&lt;td&gt;Strands most of the plan&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Inference (16 × &lt;code&gt;inf2.xlarge&lt;/code&gt; at $0.7582, 4 × &lt;code&gt;g6.xlarge&lt;/code&gt; at $0.8048)&lt;/td&gt;
&lt;td&gt;~$15.35&lt;/td&gt;
&lt;td&gt;~$11.50&lt;/td&gt;
&lt;td&gt;Strands it, and the port isn't done anyway&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Total eligible&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;~$59.25&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;~$44.45&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Headroom over $30 commitment: &lt;strong&gt;~$14.45/hr&lt;/strong&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The API tier ($12.75/hr) fits inside the $14.45/hr headroom, so it can move any time. EKS can't: moving it early leaves roughly $18.50/hr of commitment uncovered, about $13,500 a month at 730 hours, on top of the GKE bill that replaces it. The inference fleet is the best Savings Plan sink you have, because it needs a code port before it can move at all.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Order waves by what each one does to the commitment, not by risk alone.&lt;/strong&gt; Spot workers and the API tier move first, EKS lands in the last weeks of the plan, and the Inferentia fleet keeps soaking up the commitment while the port is benchmarked.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Decision 2: machine families, priced from measurements
&lt;/h2&gt;

&lt;p&gt;A &lt;code&gt;c6i.2xlarge&lt;/code&gt; is 8 vCPUs and 16 GiB. Our API tier uses 45% CPU at p95 and 9 GiB of memory, so we keep 8 vCPUs for latency headroom and size memory to 12 GiB. Here are the candidates in us-central1 at list price as of November 2026 [7]:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Machine&lt;/th&gt;
&lt;th&gt;Shape&lt;/th&gt;
&lt;th&gt;On-demand $/hr&lt;/th&gt;
&lt;th&gt;1-yr flexible CUD $/hr&lt;/th&gt;
&lt;th&gt;40 VMs/month on-demand&lt;/th&gt;
&lt;th&gt;Notes&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;AWS &lt;code&gt;c6i.2xlarge&lt;/code&gt; (us-east-1)&lt;/td&gt;
&lt;td&gt;8 vCPU, 16 GiB&lt;/td&gt;
&lt;td&gt;$0.3400&lt;/td&gt;
&lt;td&gt;n/a&lt;/td&gt;
&lt;td&gt;$9,928&lt;/td&gt;
&lt;td&gt;Baseline&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n2d-custom-8-12288&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;8 vCPU, 12 GiB&lt;/td&gt;
&lt;td&gt;$0.2775&lt;/td&gt;
&lt;td&gt;$0.1998&lt;/td&gt;
&lt;td&gt;$8,102&lt;/td&gt;
&lt;td&gt;AMD Milan; Persistent Disk or Hyperdisk&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n4-highcpu-8&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;8 vCPU, 16 GiB&lt;/td&gt;
&lt;td&gt;$0.3062&lt;/td&gt;
&lt;td&gt;$0.2204&lt;/td&gt;
&lt;td&gt;$8,940&lt;/td&gt;
&lt;td&gt;Intel Emerald Rapids; Hyperdisk only&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;c4a-highcpu-8&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;8 vCPU, 16 GiB (Arm)&lt;/td&gt;
&lt;td&gt;$0.3030&lt;/td&gt;
&lt;td&gt;$0.2182&lt;/td&gt;
&lt;td&gt;$8,849&lt;/td&gt;
&lt;td&gt;Axion; needs Arm images&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;c4-highcpu-8&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;8 vCPU, 16 GiB&lt;/td&gt;
&lt;td&gt;$0.3402&lt;/td&gt;
&lt;td&gt;$0.2449&lt;/td&gt;
&lt;td&gt;$9,934&lt;/td&gt;
&lt;td&gt;Highest per-core performance; Hyperdisk only&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n2d-highcpu-8&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;8 vCPU, 8 GiB&lt;/td&gt;
&lt;td&gt;$0.2495&lt;/td&gt;
&lt;td&gt;$0.1796&lt;/td&gt;
&lt;td&gt;$7,286&lt;/td&gt;
&lt;td&gt;Rejected: 8 GiB is under our 9 GiB p95&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;List price per VM isn't the decision. Price per request at your SLO is. Divide each price by the requests per second one VM sustains under your p99 target. That gives a clean flip rule against the cheapest option that fits:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;N4 beats N2D&lt;/strong&gt; only if one &lt;code&gt;n4-highcpu-8&lt;/code&gt; serves at least &lt;strong&gt;10.3% more&lt;/strong&gt; requests per second than one &lt;code&gt;n2d-custom-8-12288&lt;/code&gt; ($0.3062 / $0.2775). The ratio is the same under a 1-year flexible CUD.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;C4 beats N2D&lt;/strong&gt; only above &lt;strong&gt;22.6% more&lt;/strong&gt; throughput per VM.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;C4A (Arm) beats N2D&lt;/strong&gt; above &lt;strong&gt;9.2% more&lt;/strong&gt;, but only if every image, native dependency and agent you run ships an arm64 build. If one doesn't, the rebuild cost decides it, not the price.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Run the benchmark with a replay of real traffic, not a synthetic CPU test. Newer cores often clear the 10% bar on request-heavy services, so don't assume the cheapest list price wins.&lt;/p&gt;

&lt;h3&gt;
  
  
  Two pricing traps in this table
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Sustained use discounts may not apply to you.&lt;/strong&gt; N2, N2D and C2 earn up to 20% off for a full month of use, and N1 up to 30% [3]. That makes on-demand &lt;code&gt;n2d-custom-8-12288&lt;/code&gt; about $0.2220/hr, close to a 1-year N4 commitment without committing. But Google's docs state that only self-serve (online) Cloud Billing accounts receive sustained use discounts, and usage covered by a CUD doesn't get them either [3]. If your company signed a contract and pays by invoice, check your billing account type before you build a plan on sustained use discounts.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Custom shapes carry a premium.&lt;/strong&gt; On N4, a custom 8 vCPU / 12 GiB shape costs $0.3066/hr against $0.3062/hr for the predefined 8 vCPU / 16 GiB &lt;code&gt;n4-highcpu-8&lt;/code&gt; [7]. Trimming memory with a custom type saves nothing there. On N2D the same trim does pay, because the next predefined shape up is the 32 GiB &lt;code&gt;n2d-standard-8&lt;/code&gt; at $0.3380/hr.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two hardware details also bite. N4 and C4A don't support Persistent Disk at all, so a template that says &lt;code&gt;pd-balanced&lt;/code&gt; on an N4 machine fails to create [8]. And if you pick N2 instead of N2D, custom shapes default to Cascade Lake, an older core than the Ice Lake in a &lt;code&gt;c6i&lt;/code&gt;; set &lt;code&gt;min_cpu_platform = "Intel Ice Lake"&lt;/code&gt; or your benchmark compares the wrong silicon [8].&lt;/p&gt;

&lt;p&gt;Our pick for the scenario: &lt;code&gt;n2d-custom-8-12288&lt;/code&gt;, unless N4 clears the 10.3% bar in the replay. That saves about $1,826 a month against the AWS On-Demand baseline before any commitment, and about $4,095 a month once the baseline is covered by a 1-year flexible CUD.&lt;/p&gt;

&lt;h3&gt;
  
  
  From Auto Scaling group to managed instance group
&lt;/h3&gt;

&lt;p&gt;An Auto Scaling group becomes a regional managed instance group (MIG) built from an instance template, plus an autoscaler. Three differences matter in practice:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Zones.&lt;/strong&gt; A regional MIG spreads across zones by itself, because a GCP subnet covers the whole region. You stop listing one subnet per Availability Zone.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Health checks.&lt;/strong&gt; On AWS you set &lt;code&gt;health_check_type = "ELB"&lt;/code&gt;. On GCP, autohealing uses a health check you attach to the MIG. Give it an initial delay longer than your slowest cold start, or the MIG will recreate VMs that were still booting.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mixed instance types.&lt;/strong&gt; &lt;code&gt;mixed_instances_policy&lt;/code&gt; becomes the MIG's instance flexibility setting, which lists several machine types for one regional group.
&lt;/li&gt;
&lt;/ul&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="c1"&gt;# AWS: one of the three API groups&lt;/span&gt;
&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"aws_autoscaling_group"&lt;/span&gt; &lt;span class="s2"&gt;"api"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;min_size&lt;/span&gt;            &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;14&lt;/span&gt;
  &lt;span class="nx"&gt;max_size&lt;/span&gt;            &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;22&lt;/span&gt;
  &lt;span class="nx"&gt;vpc_zone_identifier&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;private_subnet_ids&lt;/span&gt;
  &lt;span class="nx"&gt;health_check_type&lt;/span&gt;   &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"ELB"&lt;/span&gt;
  &lt;span class="nx"&gt;launch_template&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;id&lt;/span&gt;      &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;aws_launch_template&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;api&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
    &lt;span class="nx"&gt;version&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="err"&gt;$&lt;/span&gt;&lt;span class="s2"&gt;Latest"&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="c1"&gt;# GCP: the same group as a regional MIG&lt;/span&gt;
&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_compute_instance_template"&lt;/span&gt; &lt;span class="s2"&gt;"api"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;machine_type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"n2d-custom-8-12288"&lt;/span&gt; &lt;span class="c1"&gt;# 8 vCPU, 12 GiB: p95 memory was 9 GiB&lt;/span&gt;
  &lt;span class="nx"&gt;disk&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;source_image&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;api_image&lt;/span&gt;
    &lt;span class="nx"&gt;disk_type&lt;/span&gt;    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"pd-balanced"&lt;/span&gt; &lt;span class="c1"&gt;# fine on N2D; would fail on N4 or C4A&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="c1"&gt;# network_interface and service_account blocks go here&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_compute_region_instance_group_manager"&lt;/span&gt; &lt;span class="s2"&gt;"api"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;               &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"api"&lt;/span&gt;
  &lt;span class="nx"&gt;base_instance_name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"api"&lt;/span&gt;
  &lt;span class="nx"&gt;region&lt;/span&gt;             &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"us-central1"&lt;/span&gt; &lt;span class="c1"&gt;# spreads across zones by itself&lt;/span&gt;
  &lt;span class="nx"&gt;version&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;instance_template&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_compute_instance_template&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;api&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="nx"&gt;auto_healing_policies&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;health_check&lt;/span&gt;      &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_compute_health_check&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;api&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
    &lt;span class="nx"&gt;initial_delay_sec&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;180&lt;/span&gt; &lt;span class="c1"&gt;# slowest measured cold start was 140 s&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_compute_region_autoscaler"&lt;/span&gt; &lt;span class="s2"&gt;"api"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;   &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"api"&lt;/span&gt;
  &lt;span class="nx"&gt;region&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"us-central1"&lt;/span&gt;
  &lt;span class="nx"&gt;target&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_compute_region_instance_group_manager&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;api&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;autoscaling_policy&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;min_replicas&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;14&lt;/span&gt;
    &lt;span class="nx"&gt;max_replicas&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;22&lt;/span&gt;
    &lt;span class="nx"&gt;cpu_utilization&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;target&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mf"&gt;0.6&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Inside the VM, the AWS plumbing changes too:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;On AWS&lt;/th&gt;
&lt;th&gt;On GCP&lt;/th&gt;
&lt;th&gt;What breaks if you forget&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;IMDSv2 at &lt;code&gt;169.254.169.254&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Metadata server at &lt;code&gt;metadata.google.internal&lt;/code&gt; (needs the &lt;code&gt;Metadata-Flavor: Google&lt;/code&gt; header)&lt;/td&gt;
&lt;td&gt;Scripts that read region, instance ID or credentials return 404s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Instance profile&lt;/td&gt;
&lt;td&gt;Service account attached to the VM&lt;/td&gt;
&lt;td&gt;Code falls back to access keys hidden in env files&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EC2 user data&lt;/td&gt;
&lt;td&gt;Startup script in instance metadata&lt;/td&gt;
&lt;td&gt;Bootstrap silently doesn't run&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SSM Session Manager&lt;/td&gt;
&lt;td&gt;OS Login plus IAP TCP forwarding&lt;/td&gt;
&lt;td&gt;Someone opens port 22 to the internet&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CloudWatch agent&lt;/td&gt;
&lt;td&gt;Ops Agent&lt;/td&gt;
&lt;td&gt;Alerts go quiet on cutover day&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Amazon Linux AMIs&lt;/td&gt;
&lt;td&gt;Debian, Ubuntu, RHEL, Rocky or Container-Optimized OS&lt;/td&gt;
&lt;td&gt;Amazon Linux doesn't run on Compute Engine; packages differ&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;One thing gets better without effort: most Compute Engine VMs live-migrate during host maintenance instead of rebooting. GPU VMs are the exception and still stop, which matters for the inference fleet below.&lt;/p&gt;

&lt;h2&gt;
  
  
  Decision 3: Spot drain logic for a 30-second window
&lt;/h2&gt;

&lt;p&gt;Our workers drain for 90 seconds: stop pulling, finish the job in hand (up to 70 s), acknowledge it, exit. That logic was built for the EC2 two-minute interruption notice [15]. GCP gives you much less by default.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;EC2 Spot&lt;/th&gt;
&lt;th&gt;GCP Spot VMs&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Warning&lt;/td&gt;
&lt;td&gt;Two minutes, best effort [15]&lt;/td&gt;
&lt;td&gt;Best-effort shutdown period of up to 30 seconds; a 120-second preemption notice is in Preview [2]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;On Kubernetes&lt;/td&gt;
&lt;td&gt;Node termination handler, then pod grace period&lt;/td&gt;
&lt;td&gt;GKE Spot nodes: regular pods get 15 s, then system pods 15 s; extending it needs GKE 1.35 or later, up to 120 s total [9]&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Early hint&lt;/td&gt;
&lt;td&gt;Rebalance recommendation, often before the notice [19]&lt;/td&gt;
&lt;td&gt;None&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Signal&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;spot/instance-action&lt;/code&gt; in metadata, EventBridge event&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;preempted&lt;/code&gt; = &lt;code&gt;TRUE&lt;/code&gt; in metadata, ACPI soft-off signal&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Price&lt;/td&gt;
&lt;td&gt;Moves with supply and demand&lt;/td&gt;
&lt;td&gt;Can change up to once a day [2]&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A 90-second drain on a 30-second window means every preemption leaves a job half-done and never acknowledged. You have three options:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Option&lt;/th&gt;
&lt;th&gt;What it costs you&lt;/th&gt;
&lt;th&gt;Pick it when&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Spot, drain rewritten to under 25 s: stop pulling, release in-flight jobs back to the queue, exit&lt;/td&gt;
&lt;td&gt;Jobs must be idempotent; preempted jobs rerun from the start&lt;/td&gt;
&lt;td&gt;Jobs are short or checkpointed, and a duplicate is harmless&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Spot with the 120-second notice&lt;/td&gt;
&lt;td&gt;A Preview feature under your production queue&lt;/td&gt;
&lt;td&gt;You're testing, not running production&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;On-demand VMs&lt;/td&gt;
&lt;td&gt;About twice the Spot price&lt;/td&gt;
&lt;td&gt;Jobs are long, not idempotent, and can't be made so cheaply&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The money, for 30 workers on the same 8 vCPU / 12 GiB N2D shape in us-central1 (Spot price on the day we checked; it can change daily) [10]:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Spot &lt;code&gt;n2d-custom-8-12288&lt;/code&gt;: $0.1406/hr, about &lt;strong&gt;$3,078 a month&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;On-demand: $0.2775/hr, about &lt;strong&gt;$6,076 a month&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;Spot stays cheaper as long as reruns waste less than &lt;strong&gt;49%&lt;/strong&gt; of worker time (1 − 0.1406 / 0.2775). If you do get sustained use discounts, the bar is 37%.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;With jobs under 70 seconds, reruns will never come close to that bar. The cost case for Spot holds easily. The real risk is correctness: a worker that's killed mid-job and redelivered processes the job twice unless it's idempotent. So the work is an idempotency key on every job and a drain that gives the job back instead of finishing it:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Block until Compute Engine marks this VM preempted, then drain fast.&lt;/span&gt;
&lt;span class="c"&gt;# Runs as a sidecar process next to the worker.&lt;/span&gt;
curl &lt;span class="nt"&gt;-s&lt;/span&gt; &lt;span class="nt"&gt;-H&lt;/span&gt; &lt;span class="s2"&gt;"Metadata-Flavor: Google"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="s2"&gt;"http://metadata.google.internal/computeMetadata/v1/instance/preempted?wait_for_change=true"&lt;/span&gt;

&lt;span class="c"&gt;# Returns TRUE on preemption. The worker then has about 25 s to:&lt;/span&gt;
&lt;span class="c"&gt;#   1. stop pulling new messages&lt;/span&gt;
&lt;span class="c"&gt;#   2. release in-flight messages (visibility timeout 0 or nack)&lt;/span&gt;
&lt;span class="c"&gt;#   3. flush metrics and exit 0&lt;/span&gt;
&lt;span class="nb"&gt;kill&lt;/span&gt; &lt;span class="nt"&gt;-TERM&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="si"&gt;$(&lt;/span&gt;&lt;span class="nb"&gt;cat&lt;/span&gt; /run/worker.pid&lt;span class="si"&gt;)&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Measure two numbers in the pilot: preemptions per day per zone, and the share of jobs processed more than once (count duplicate idempotency keys). If duplicates show up in downstream tables, the drain isn't releasing messages fast enough.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_compute_instance_template"&lt;/span&gt; &lt;span class="s2"&gt;"worker"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;machine_type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"n2d-custom-8-12288"&lt;/span&gt;
  &lt;span class="nx"&gt;scheduling&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;provisioning_model&lt;/span&gt;          &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"SPOT"&lt;/span&gt;
    &lt;span class="nx"&gt;preemptible&lt;/span&gt;                 &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
    &lt;span class="nx"&gt;automatic_restart&lt;/span&gt;           &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
    &lt;span class="nx"&gt;instance_termination_action&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"DELETE"&lt;/span&gt; &lt;span class="c1"&gt;# the MIG recreates it&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="c1"&gt;# disk, network_interface and service_account blocks go here&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Decision 4: size the GKE pod range before the cluster exists
&lt;/h2&gt;

&lt;p&gt;Manifests and Helm charts mostly move as they are. The cluster around them doesn't, and the piece you can't fix later is IP space.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frk5a69qhksl42k84k0r6.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frk5a69qhksl42k84k0r6.png" alt="What changes around the cluster from EKS to GKE: pod IPs from the node subnet become secondary ranges, EKS Pod Identity or IRSA becomes Workload Identity Federation, the AWS Load Balancer Controller becomes GKE Ingress or Gateway, Karpenter or Auto Mode becomes node auto-provisioning or Autopilot, and the EBS CSI driver becomes the PD CSI driver" width="799" height="369"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;On EKS with the VPC CNI, each pod takes an address from the node subnet, so IP use tracks pod count. GKE works differently. Pods come from a secondary range, and every node reserves a whole block sized from its maximum pods setting, whether it runs 3 pods or 100. At the Standard default of 110 pods per node, that block is a /24 [6]. The pod range size can't be changed after the cluster is created; you can only add more ranges later with discontiguous multi-pod CIDR [6].&lt;/p&gt;

&lt;p&gt;Now the math for our prod cluster. Karpenter peaks at 140 nodes. A blue-green node pool upgrade temporarily doubles a pool's nodes [11], so plan for 280. Our densest nodes run 41 pods, DaemonSets included.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Max pods per node&lt;/th&gt;
&lt;th&gt;Block per node&lt;/th&gt;
&lt;th&gt;Nodes in a /16&lt;/th&gt;
&lt;th&gt;Nodes in a /17&lt;/th&gt;
&lt;th&gt;Verdict for 280 nodes&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;110 (default)&lt;/td&gt;
&lt;td&gt;/24 (256 IPs)&lt;/td&gt;
&lt;td&gt;256&lt;/td&gt;
&lt;td&gt;128&lt;/td&gt;
&lt;td&gt;Needs a /15: 131,072 addresses for 1,400 pods&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;64&lt;/td&gt;
&lt;td&gt;/25 (128 IPs)&lt;/td&gt;
&lt;td&gt;512&lt;/td&gt;
&lt;td&gt;256&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;/16 fits with headroom.&lt;/strong&gt; Our pick&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;32&lt;/td&gt;
&lt;td&gt;/26 (64 IPs)&lt;/td&gt;
&lt;td&gt;1,024&lt;/td&gt;
&lt;td&gt;512&lt;/td&gt;
&lt;td&gt;/17 fits, but our densest nodes already run 41 pods&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Pick ranges that don't overlap the AWS VPC (here &lt;code&gt;10.0.0.0/16&lt;/code&gt;), because during coexistence pods will talk to AWS over the VPN. GKE doesn't masquerade traffic to private ranges by default, so AWS will see pod IPs: the pod range has to be routed over the VPN and allowed in the AWS security groups.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight terraform"&gt;&lt;code&gt;&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_compute_subnetwork"&lt;/span&gt; &lt;span class="s2"&gt;"gke_prod"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;          &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"gke-prod"&lt;/span&gt;
  &lt;span class="nx"&gt;region&lt;/span&gt;        &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"us-central1"&lt;/span&gt;
  &lt;span class="nx"&gt;network&lt;/span&gt;       &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_compute_network&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;main&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;ip_cidr_range&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"10.80.0.0/22"&lt;/span&gt; &lt;span class="c1"&gt;# nodes: 1,020 usable&lt;/span&gt;
  &lt;span class="nx"&gt;secondary_ip_range&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;range_name&lt;/span&gt;    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"pods"&lt;/span&gt;
    &lt;span class="nx"&gt;ip_cidr_range&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"10.96.0.0/16"&lt;/span&gt; &lt;span class="c1"&gt;# 512 nodes at /25 each&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="nx"&gt;secondary_ip_range&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;range_name&lt;/span&gt;    &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"services"&lt;/span&gt;
    &lt;span class="nx"&gt;ip_cidr_range&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"10.81.0.0/20"&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;resource&lt;/span&gt; &lt;span class="s2"&gt;"google_container_cluster"&lt;/span&gt; &lt;span class="s2"&gt;"prod"&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nx"&gt;name&lt;/span&gt;                      &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"prod"&lt;/span&gt;
  &lt;span class="nx"&gt;location&lt;/span&gt;                  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"us-central1"&lt;/span&gt;
  &lt;span class="nx"&gt;network&lt;/span&gt;                   &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_compute_network&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;main&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;subnetwork&lt;/span&gt;                &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;google_compute_subnetwork&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;gke_prod&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;
  &lt;span class="nx"&gt;default_max_pods_per_node&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;64&lt;/span&gt; &lt;span class="c1"&gt;# /25 per node instead of /24&lt;/span&gt;
  &lt;span class="nx"&gt;ip_allocation_policy&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;cluster_secondary_range_name&lt;/span&gt;  &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"pods"&lt;/span&gt;
    &lt;span class="nx"&gt;services_secondary_range_name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"services"&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="nx"&gt;workload_identity_config&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;workload_pool&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;project_id&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;.svc.id.goog"&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="nx"&gt;remove_default_node_pool&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
  &lt;span class="nx"&gt;initial_node_count&lt;/span&gt;       &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If you get this wrong, it shows up as nodes that never arrive and pods stuck in Pending, with this in the logs [12]:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[IP_SPACE_EXHAUSTED] Instance 'gke-prod-pool-1-...' creation failed: IP space of
'projects/acme-prod/regions/us-central1/subnetworks/gke-prod-pods-1a2b3c4d' is exhausted.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Alert on that string in Cloud Logging, and watch pod range allocation in Network Intelligence Center during load tests. Allocation counts every node's full block, not the pods actually running.&lt;/p&gt;

&lt;h3&gt;
  
  
  IRSA and Pod Identity to Workload Identity Federation
&lt;/h3&gt;

&lt;p&gt;Our 35 IRSA roles each become IAM bindings for a Kubernetes service account. Start with the inventory, because roles hide in annotations and in Pod Identity associations:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# IRSA: service accounts annotated with an IAM role&lt;/span&gt;
kubectl get sa &lt;span class="nt"&gt;-A&lt;/span&gt; &lt;span class="nt"&gt;-o&lt;/span&gt; json | jq &lt;span class="nt"&gt;-r&lt;/span&gt; &lt;span class="s1"&gt;'.items[]
  | select(.metadata.annotations["eks.amazonaws.com/role-arn"])
  | "\(.metadata.namespace)/\(.metadata.name)  \(.metadata.annotations["eks.amazonaws.com/role-arn"])"'&lt;/span&gt;

&lt;span class="c"&gt;# EKS Pod Identity: associations live outside the cluster&lt;/span&gt;
aws eks list-pod-identity-associations &lt;span class="nt"&gt;--cluster-name&lt;/span&gt; prod
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On GKE you can grant roles straight to the Kubernetes service account as a principal, with no annotation and no Google service account in between [13]:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gcloud storage buckets add-iam-policy-binding gs://acme-invoices &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--role&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;roles/storage.objectViewer &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--member&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"principal://iam.googleapis.com/projects/123456789012/locations/global/workloadIdentityPools/acme-prod.svc.id.goog/subject/ns/billing/sa/invoice-worker"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Direct access has per-product limitations. Where a Google API doesn't support it, fall back to linking the Kubernetes service account to an IAM service account with &lt;code&gt;roles/iam.workloadIdentityUser&lt;/code&gt; and the &lt;code&gt;iam.gke.io/gcp-service-account&lt;/code&gt; annotation [13]. Workload Identity Federation is always on in Autopilot; on Standard you enable it on the cluster, as in the Terraform above.&lt;/p&gt;

&lt;p&gt;The failure you'll see in week one is a pod that still needs S3 because the data hasn't moved yet. The AWS SDK finds no credentials on GKE and throws &lt;code&gt;Unable to locate credentials&lt;/code&gt;. Plan for it: either keep that workload on EKS until its data moves, or give it an AWS role that trusts Google-issued identity tokens through web identity federation. Don't copy an AWS access key into a Kubernetes Secret as a shortcut; that key outlives the migration.&lt;/p&gt;

&lt;h3&gt;
  
  
  Nodes, ingress and storage
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Nodes.&lt;/strong&gt; Karpenter maps to GKE Standard with node auto-provisioning or custom compute classes. EKS Auto Mode maps most closely to Autopilot, but Autopilot bills for the CPU and memory your pods request, not for nodes, and blocks some pod settings such as privileged containers. With a platform team of three and Karpenter today, we'd pick Standard and keep node-level control.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ingress.&lt;/strong&gt; The AWS Load Balancer Controller and its annotations go. GKE's Ingress and Gateway controllers create Google load balancers that send traffic straight to pods. Every Ingress gets rewritten, so it's a good moment to move to the Gateway API.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Storage.&lt;/strong&gt; EBS volumes through the EBS CSI driver become Persistent Disk or Hyperdisk through the Compute Engine PD CSI driver. Check that each StorageClass disk type matches the node machine series.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fee.&lt;/strong&gt; GKE charges $0.10 per cluster per hour, with a monthly free-tier credit [5]. Same as EKS standard support.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Decision 5: the Inferentia fleet has nowhere to land
&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;g6.xlarge&lt;/code&gt; machines are the easy part. Same NVIDIA L4, CUDA code unchanged, and &lt;code&gt;g2-standard-4&lt;/code&gt; (1 × L4, 4 vCPU, 16 GiB) lists at $0.7068/hr in us-central1 against $0.8048/hr for &lt;code&gt;g6.xlarge&lt;/code&gt; in us-east-1 [18][14], about 12% less.&lt;/p&gt;

&lt;p&gt;The 16 &lt;code&gt;inf2.xlarge&lt;/code&gt; machines are different. GCP has no Inferentia or Trainium, so a model compiled with the Neuron SDK has to be ported, not moved. Three options:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Option&lt;/th&gt;
&lt;th&gt;Cost per month (16 machines, list)&lt;/th&gt;
&lt;th&gt;What it costs you&lt;/th&gt;
&lt;th&gt;Pick it when&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Keep on AWS &lt;code&gt;inf2.xlarge&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;$8,856 (at $0.7582/hr)&lt;/td&gt;
&lt;td&gt;Cross-cloud calls from GCP callers: added latency and data transfer out of AWS&lt;/td&gt;
&lt;td&gt;The Savings Plan still has months to run, or the port fails the benchmark&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Port to L4 on &lt;code&gt;g2-standard-4&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;$8,256 at 1:1 (at $0.7068/hr)&lt;/td&gt;
&lt;td&gt;Engineering time to remove Neuron tracing, fixed-shape bucketing and any custom NKI kernels&lt;/td&gt;
&lt;td&gt;One L4 serves at least 93% of one &lt;code&gt;inf2.xlarge&lt;/code&gt; throughput at your p99&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Port to Cloud TPU&lt;/td&gt;
&lt;td&gt;Benchmark first&lt;/td&gt;
&lt;td&gt;JAX or PyTorch/XLA rework and per-model testing&lt;/td&gt;
&lt;td&gt;The fleet is large enough that a cost gap pays for the rewrite&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The flip point for the L4 port is a throughput ratio, not a price. &lt;code&gt;g2-standard-4&lt;/code&gt; costs 93.2% of &lt;code&gt;inf2.xlarge&lt;/code&gt; per hour, so the port breaks even if one L4 sustains at least 93.2% of an Inferentia2 machine's requests per second at the 40 ms p99. If the replay shows 80%, you need 20 L4 machines and the bill rises to about $10,320 a month. GPU VMs on accelerator-optimized machine types don't receive sustained use discounts [3], so price commitments or Spot on top only for the steady base.&lt;/p&gt;

&lt;p&gt;For a plain PyTorch model, the port is mostly removing code:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="c1"&gt;# Before: AWS Inferentia2, compiled for fixed input shapes
&lt;/span&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;torch_neuronx&lt;/span&gt;
&lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;load_ranker&lt;/span&gt;&lt;span class="p"&gt;().&lt;/span&gt;&lt;span class="nf"&gt;eval&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;neuron_model&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;torch_neuronx&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;trace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;example_inputs&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c1"&gt;# one compile per shape bucket
&lt;/span&gt;&lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;jit&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;save&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;neuron_model&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ranker_neuron.pt&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c1"&gt;# After: NVIDIA L4, standard PyTorch
&lt;/span&gt;&lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;load_ranker&lt;/span&gt;&lt;span class="p"&gt;().&lt;/span&gt;&lt;span class="nf"&gt;eval&lt;/span&gt;&lt;span class="p"&gt;().&lt;/span&gt;&lt;span class="nf"&gt;to&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;cuda&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;half&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;compile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;mode&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;max-autotune&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="c1"&gt;# Drop the shape-bucketing and padding logic in the request path,
# then re-tune batch size: the NeuronCore-optimal batch is rarely the L4-optimal one.
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Custom Neuron kernels are a rewrite, and that's where the estimate can blow up. For a 16-machine fleet, a TPU port rarely pays back; revisit it when the accelerator bill is large enough to fund a quarter of engineering. Two operational notes: G2 VMs stop for host maintenance rather than live-migrating, so run them in a MIG or GKE node pool with spare capacity, and GPU quota in a new project starts low, so request L4 quota before the benchmark, not after. For large fixed-period GPU needs, Dynamic Workload Scheduler plays the role EC2 Capacity Blocks for ML play on AWS.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Our call for the scenario:&lt;/strong&gt; move the &lt;code&gt;g6&lt;/code&gt; machines in the API wave, keep the Inferentia fleet on AWS as a Savings Plan sink, and port it to L4 only after a production replay clears the 93% throughput bar.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  The rest of the estate
&lt;/h2&gt;

&lt;p&gt;Everything that didn't drive a decision above maps more simply. Rehost servers nobody can rebuild; rebuild everything that's already code.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0jrnpweh592sj1rk0aiy.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0jrnpweh592sj1rk0aiy.png" alt="Two ways to move an EC2 instance: rehost with Migrate to Virtual Machines, which connects to the AWS account, replicates EBS snapshots continuously, runs a test clone and then cuts over; or rebuild with Packer, producing a custom image that a managed instance group launches" width="800" height="285"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;AWS&lt;/th&gt;
&lt;th&gt;GCP&lt;/th&gt;
&lt;th&gt;Decision note&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Hand-built EC2 servers&lt;/td&gt;
&lt;td&gt;Migrate to Virtual Machines&lt;/td&gt;
&lt;td&gt;Uses your AWS account as a source, replicates EBS volumes, runs a test clone, then cuts over [1]. The service is free; you pay AWS for snapshots, helper instances and data out while it replicates&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Packer- or Ansible-built AMIs&lt;/td&gt;
&lt;td&gt;Custom images via Packer's &lt;code&gt;googlecompute&lt;/code&gt; builder, launched by a MIG&lt;/td&gt;
&lt;td&gt;More work up front, but rebuildable any time&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dedicated Hosts&lt;/td&gt;
&lt;td&gt;Sole-tenant nodes&lt;/td&gt;
&lt;td&gt;Usually for per-core licences. Price Google's licence-included images first; they often remove the need&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EC2 bare metal&lt;/td&gt;
&lt;td&gt;Bare metal shapes on C3, C4 and X4, or Bare Metal Solution&lt;/td&gt;
&lt;td&gt;Bare Metal Solution is for cases like Oracle RAC&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AWS Batch&lt;/td&gt;
&lt;td&gt;Batch on Compute Engine, Spot or standard&lt;/td&gt;
&lt;td&gt;Same 30-second Spot rule applies to checkpoints. AWS Batch on EKS fits better as GKE plus Kueue&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AWS ParallelCluster&lt;/td&gt;
&lt;td&gt;Cluster Toolkit&lt;/td&gt;
&lt;td&gt;HPC clusters rebuild from blueprints&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ALB / NLB&lt;/td&gt;
&lt;td&gt;External Application or Network Load Balancer&lt;/td&gt;
&lt;td&gt;The global Application Load Balancer has one anycast IP, so latency routing in front of it is often unnecessary&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Networking needs its own plan: GCP VPCs are global and subnets are regional, so per-AZ subnets and Transit Gateway meshes collapse. Security groups become firewall rules that target service accounts or secure tags; rewrite them that way rather than by IP range. Cross-zone traffic is still billed per GB on GCP, and Cloud NAT charges per GB like NAT Gateway, so the bill shape doesn't change much.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fv44ly605icup4j0dwydc.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fv44ly605icup4j0dwydc.png" alt="Compute decision flow: if it runs on Trainium or Inferentia, port first; if it is on Kubernetes and staying there, GKE; if it is batch or interruptible, Batch on Spot VMs; if it needs per-core licences or dedicated hardware, sole-tenant nodes or licence-included images; otherwise Compute Engine in a managed instance group" width="800" height="353"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Cutover and rollback
&lt;/h2&gt;

&lt;p&gt;Before the first wave, pick the region on purpose. Prices above are us-central1. While databases stay in us-east-1, every API call that reaches them crosses the VPN. If that hop pushes your p99 past the SLO, us-east4 in Northern Virginia sits much closer to us-east-1, at higher list prices, so rerun the table with its rates.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Baseline on AWS.&lt;/strong&gt; Record two weeks of p50 and p99 latency, 5xx rate, queue age and cost per 1,000 requests for every tier. Without this, there's nothing to compare GCP against.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Build the base.&lt;/strong&gt; Projects, Shared VPC with the pod ranges above, HA VPN or Cross-Cloud Interconnect to AWS, quotas for CPUs, L4 GPUs and IPs, Ops Agent and alerts rebuilt from CloudWatch.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wave 1: Spot workers.&lt;/strong&gt; No Savings Plan impact. Run them alongside the AWS workers on the same queue, then scale AWS to zero once the duplicate rate is flat.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wave 2: API tier and &lt;code&gt;g6&lt;/code&gt; machines.&lt;/strong&gt; Lower DNS TTLs to 60 seconds a few days ahead. Shift with weighted records at 5%, 25%, 50% and 100%, holding each step until the gates below pass for a full business day.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wave 3: EKS.&lt;/strong&gt; Timed for the last weeks of the Savings Plan. Move namespace by namespace, with identity bindings and ingress verified per namespace.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Wave 4: inference.&lt;/strong&gt; Only after the L4 replay passes, or stays on AWS by decision.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Commit last.&lt;/strong&gt; Buy flexible CUDs for the measured steady baseline once two or three billing cycles are stable. Spend-based flexible CUDs cover Compute Engine, GKE and Cloud Run [4], so they survive a later family change.&lt;/li&gt;
&lt;/ol&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Metric&lt;/th&gt;
&lt;th&gt;Gate to raise the weight&lt;/th&gt;
&lt;th&gt;Rollback trigger&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;API p99 latency&lt;/td&gt;
&lt;td&gt;Within 10% of the AWS baseline&lt;/td&gt;
&lt;td&gt;More than 20% over baseline for 15 minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5xx rate&lt;/td&gt;
&lt;td&gt;No higher than baseline + 0.1 points&lt;/td&gt;
&lt;td&gt;Twice the baseline for 5 minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Queue age (workers)&lt;/td&gt;
&lt;td&gt;At or below AWS baseline&lt;/td&gt;
&lt;td&gt;Growing for 30 minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Duplicate job rate&lt;/td&gt;
&lt;td&gt;Flat after the Spot pilot&lt;/td&gt;
&lt;td&gt;Any rise in downstream duplicate keys&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pending pods / &lt;code&gt;IP_SPACE_EXHAUSTED&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Zero during load test&lt;/td&gt;
&lt;td&gt;Any occurrence in prod&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cost per 1,000 requests (billing export)&lt;/td&gt;
&lt;td&gt;Within 10% of plan&lt;/td&gt;
&lt;td&gt;Investigate, don't roll back&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Rollback is only real if the old path is warm. Keep each AWS Auto Scaling group at a reduced minimum, not zero, until GCP has held 100% for two weeks. For the API tier that's 6 &lt;code&gt;c6i.2xlarge&lt;/code&gt;, about $1,489 a month at On-Demand list price, which is cheap insurance against a weighted-DNS revert that has nowhere to go. Rolling back is setting the GCP weight to 0; with a 60-second TTL most clients follow within minutes, but some resolvers cache longer, so leave GCP serving until its traffic drains.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Ask AWS about exit fees before the data moves.&lt;/strong&gt; AWS waives data transfer out to the internet for customers moving all their data off AWS. You contact AWS Support first. AWS's announcement post currently gives customers outside the EU 180 days to finish (earlier versions said 60, then 90), so get the window confirmed in writing for your account [16]. Moving only part of your usage isn't covered by default, so time the request to your final data waves, not your first compute wave.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Where the scenario lands
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tier&lt;/th&gt;
&lt;th&gt;Decision&lt;/th&gt;
&lt;th&gt;What flips it&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;API&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;n2d-custom-8-12288&lt;/code&gt; regional MIGs; about $8,102/month on-demand vs $9,928 on AWS, about $5,833 with a 1-year flexible CUD&lt;/td&gt;
&lt;td&gt;N4 serving 10.3% more requests per VM, or C4A 9.2% more with arm64 images ready&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Workers&lt;/td&gt;
&lt;td&gt;Spot N2D with a 25-second drain and idempotency keys; about $3,078/month&lt;/td&gt;
&lt;td&gt;Jobs that can't be made idempotent&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EKS&lt;/td&gt;
&lt;td&gt;GKE Standard, 64 max pods per node, /16 pod range, direct Workload Identity bindings&lt;/td&gt;
&lt;td&gt;Densest nodes passing 64 pods, or the team wanting Autopilot's request-based billing&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GPU (&lt;code&gt;g6&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;g2-standard-4&lt;/code&gt;, same L4, about 12% lower list price&lt;/td&gt;
&lt;td&gt;L4 quota not granted in your region&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Inferentia&lt;/td&gt;
&lt;td&gt;Stay on AWS as a Savings Plan sink, port to L4 after benchmark&lt;/td&gt;
&lt;td&gt;L4 below 93% of &lt;code&gt;inf2.xlarge&lt;/code&gt; throughput at p99&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The service map took five minutes. The savings came from four measurements: memory at p95, requests per VM at p99, pods on the densest node and L4 throughput against Inferentia. Take those before anyone picks a machine type.&lt;/p&gt;

&lt;h2&gt;
  
  
  Common questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  How do I map EC2 instance types to GCP machine types?
&lt;/h3&gt;

&lt;p&gt;Start from measured CPU and memory, not the instance name. Shortlist series by job: E2 for light general use, N2D, N4 or C4A for general purpose, C4 or C3 for compute-heavy, highmem shapes, M3 or X4 for large memory. Then compare price per request at your SLO, and check whether a custom shape is actually cheaper than the next predefined one. On N4 it often isn't.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does the 2-minute Spot notice exist on GCP?
&lt;/h3&gt;

&lt;p&gt;Not by default. GCP Spot VMs get a best-effort shutdown period of up to 30 seconds, with a 120-second notice option in Preview. On GKE Spot nodes, regular pods get 15 seconds by default. Rewrite drain logic to release work quickly, and make jobs idempotent.&lt;/p&gt;

&lt;h3&gt;
  
  
  How big should my GKE pod range be?
&lt;/h3&gt;

&lt;p&gt;Multiply your peak node count by two if you'll use blue-green upgrades, then by the block each node reserves: /24 at 110 max pods, /25 at 64, /26 at 32. Size the secondary range to cover that, outside any CIDR your AWS VPCs use. You can't resize the range later, only add more ranges.&lt;/p&gt;

&lt;h3&gt;
  
  
  What replaces IRSA or EKS Pod Identity on GKE?
&lt;/h3&gt;

&lt;p&gt;Workload Identity Federation for GKE. Grant IAM roles directly to the Kubernetes service account's principal identifier, or link it to an IAM service account where a product doesn't support direct access.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is there a Trainium or Inferentia equivalent on GCP?
&lt;/h3&gt;

&lt;p&gt;No. Neuron-compiled models have to be ported. Plain PyTorch models usually go back to standard PyTorch on NVIDIA GPUs with modest work; custom Neuron kernels need rewriting. Cloud TPUs can be cheaper at scale but need JAX or PyTorch/XLA and per-model testing.&lt;/p&gt;

&lt;h3&gt;
  
  
  What replaces AWS Savings Plans on GCP?
&lt;/h3&gt;

&lt;p&gt;Committed use discounts. Resource-based CUDs cover a machine series in a region; spend-based flexible CUDs cover Compute Engine, GKE and Cloud Run. Sustained use discounts apply automatically to N1, N2, N2D and C2, but only on self-serve billing accounts and not on usage a CUD already covers.&lt;/p&gt;

&lt;h2&gt;
  
  
  How MigrateX handles this
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" alt="MigrateX" width="799" height="293"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;MigrateX is our platform and service for moving software, data and infrastructure from one technology to another. Automation does the repetitive work, and experienced engineers make the decisions this post walks through.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Assessment.&lt;/strong&gt; We inventory every instance, Auto Scaling group, EKS cluster, GPU machine and batch job with measured CPU, memory and pod density, plus the hidden ties to AWS: metadata calls, access keys, IRSA roles and Neuron code. We also map Savings Plan coverage, so wave order reflects the commitment.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan.&lt;/strong&gt; With your team, we price candidate machine families per tier, size pod and service ranges, choose Spot or on-demand per workload and agree the gates for each traffic shift.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Migration.&lt;/strong&gt; Automation converts launch templates and Terraform into instance templates, MIGs and GKE configuration, and runs Migrate to Virtual Machines for servers that must be rehosted. Engineers handle identity, networking, Spot drain logic and accelerator ports.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Proof.&lt;/strong&gt; Each tier runs on both clouds. We compare latency, error rate and cost per request against the AWS baseline and only raise the traffic weight when the gates pass.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Handover.&lt;/strong&gt; AWS is retired group by group, CUDs are bought against measured steady usage, and your team owns infrastructure it understands.&lt;/li&gt;
&lt;/ol&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No big switch-over weekend.&lt;/strong&gt; Traffic moves by weight, one wave at a time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A warm rollback path&lt;/strong&gt; until GCP has held full traffic.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cost decisions made in numbers.&lt;/strong&gt; Right-sizing, Spot and commitments are part of the plan, not a follow-up.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The same approach across the stack.&lt;/strong&gt; Storage, serverless, big data, and front ends like Angular, Ember and jQuery.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;Planning a move from AWS to GCP? Tell us about your setup through &lt;a href="https://cobuildx.ai/contact" rel="noopener noreferrer"&gt;Contact Us&lt;/a&gt;, and we'll start with a free conversation about where the work is likely to be.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Google Cloud
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Migrate to Virtual Machines architecture&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/migrate/virtual-machines/docs/5.0/discover/architecture" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/migrate/virtual-machines/docs/5.0/discover/architecture&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Spot VMs&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/compute/docs/instances/spot" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/compute/docs/instances/spot&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Sustained use discounts&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/compute/docs/sustained-use-discounts" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/compute/docs/sustained-use-discounts&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Committed use discounts&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/docs/cuds" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/docs/cuds&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;GKE pricing&lt;/em&gt;. &lt;a href="https://cloud.google.com/kubernetes-engine/pricing" rel="noopener noreferrer"&gt;https://cloud.google.com/kubernetes-engine/pricing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Configure maximum Pods per node&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/how-to/flexible-pod-cidr" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/kubernetes-engine/docs/how-to/flexible-pod-cidr&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;General-purpose VM pricing&lt;/em&gt; (us-central1; list prices as of November 2026). &lt;a href="https://cloud.google.com/products/compute/pricing/general-purpose" rel="noopener noreferrer"&gt;https://cloud.google.com/products/compute/pricing/general-purpose&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;General-purpose machine family&lt;/em&gt; (N4 and C4A disk support, N2 CPU platforms). &lt;a href="https://docs.cloud.google.com/compute/docs/general-purpose-machines" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/compute/docs/general-purpose-machines&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Spot VMs on GKE&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/concepts/spot-vms" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/kubernetes-engine/docs/concepts/spot-vms&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Spot VMs pricing&lt;/em&gt; (us-central1; as of November 2026). &lt;a href="https://cloud.google.com/spot-vms/pricing" rel="noopener noreferrer"&gt;https://cloud.google.com/spot-vms/pricing&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Node upgrade strategies&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/concepts/node-pool-upgrade-strategies" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/kubernetes-engine/docs/concepts/node-pool-upgrade-strategies&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Troubleshoot VPC-native clusters&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/troubleshooting/vpc-clusters" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/kubernetes-engine/docs/troubleshooting/vpc-clusters&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Authenticate to Google Cloud APIs from GKE workloads&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/how-to/workload-identity" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/kubernetes-engine/docs/how-to/workload-identity&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Accelerator-optimized VM pricing&lt;/em&gt; (us-central1; as of November 2026). &lt;a href="https://cloud.google.com/products/compute/pricing/accelerator-optimized" rel="noopener noreferrer"&gt;https://cloud.google.com/products/compute/pricing/accelerator-optimized&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  AWS
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;AWS. &lt;em&gt;Spot Instance interruption notices&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-instance-termination-notices.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-instance-termination-notices.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Free data transfer out to internet when moving out of AWS&lt;/em&gt;. &lt;a href="https://aws.amazon.com/blogs/aws/free-data-transfer-out-to-internet-when-moving-out-of-aws/" rel="noopener noreferrer"&gt;https://aws.amazon.com/blogs/aws/free-data-transfer-out-to-internet-when-moving-out-of-aws/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;What are Savings Plans?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/savingsplans/latest/userguide/what-is-savings-plans.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/savingsplans/latest/userguide/what-is-savings-plans.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon EC2 On-Demand pricing&lt;/em&gt; (US East, N. Virginia, Linux; list prices as of November 2026). &lt;a href="https://aws.amazon.com/ec2/pricing/on-demand/" rel="noopener noreferrer"&gt;https://aws.amazon.com/ec2/pricing/on-demand/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;EC2 instance rebalance recommendations&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/rebalance-recommendations.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/rebalance-recommendations.html&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Further reading
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Hyperdisk overview&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/compute/docs/disks/hyperdisks" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/compute/docs/disks/hyperdisks&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;VPC-native clusters&lt;/em&gt;. &lt;a href="https://docs.cloud.google.com/kubernetes-engine/docs/concepts/alias-ips" rel="noopener noreferrer"&gt;https://docs.cloud.google.com/kubernetes-engine/docs/concepts/alias-ips&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Migrating out of AWS just got a lot easier&lt;/em&gt;. &lt;a href="https://cloud.google.com/blog/products/infrastructure-modernization/migrating-out-of-aws-just-got-a-lot-easier" rel="noopener noreferrer"&gt;https://cloud.google.com/blog/products/infrastructure-modernization/migrating-out-of-aws-just-got-a-lot-easier&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon EKS Auto Mode&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/eks/latest/userguide/automode.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/eks/latest/userguide/automode.html&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;CobuildX helps teams migrate legacy applications and cloud infrastructure with &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;MigrateX&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/aws-to-gcp-compute-options" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>aws</category>
      <category>googlecloud</category>
      <category>cloud</category>
      <category>kubernetes</category>
    </item>
    <item>
      <title>10 Legacy Modernization Mistakes You're Making (and How to Avoid Them)</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Tue, 03 Nov 2026 12:28:11 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/10-legacy-modernization-mistakes-youre-making-and-how-to-avoid-them-4kbc</link>
      <guid>https://dev.to/cobuildx-ai/10-legacy-modernization-mistakes-youre-making-and-how-to-avoid-them-4kbc</guid>
      <description>&lt;p&gt;&lt;em&gt;Most modernization projects don't fail on the choice of framework. They fail on a handful of early decisions that only show their cost when the new system meets real users. Here are the ten we see most often, and what to do instead.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Most legacy modernization projects don't fail because the new framework is wrong. They fail because of a handful of decisions made early, often in the first planning meeting, that only show their cost months later, when the new system meets real users.&lt;/p&gt;

&lt;p&gt;Here are the ten mistakes we see most often on frontend and application modernization projects, and what to do instead. AI agents make some of them faster and easier to make, so we cover those too.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7uer9ahjpsfvx5sl4tvu.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7uer9ahjpsfvx5sl4tvu.png" alt="Ten modernization mistakes grouped by phase. Plan: no inventory first, big-bang rewrite, rewriting instead of migrating. Build: ports without tests, mixing refactor and port, ignoring hidden wiring, agents with no gates. Ship: no rollback path, cutover without parity data, declaring done too early" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Why legacy modernization projects go wrong
&lt;/h2&gt;

&lt;p&gt;A legacy app is years of decisions, fixes and workarounds that nobody wrote down. The code is the only full record of what the business actually relies on. Modernization means moving all of that onto a new stack while the business keeps running and keeps asking for changes.&lt;/p&gt;

&lt;p&gt;That makes it different from a greenfield build. The risk is less about writing new code and more about losing behavior people depend on without noticing. Most of the mistakes below come from treating a migration like a new project.&lt;/p&gt;

&lt;h2&gt;
  
  
  Planning mistakes
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Starting without an inventory
&lt;/h3&gt;

&lt;p&gt;Teams estimate from the folder structure and a few demos. Then they find the second router, the global event bus, the jQuery plugin that patches every form, and the admin screens nobody mentioned.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; map every route, component, service, global, dependency and test before you write a plan. A read-only agent can do this quickly and thoroughly. The inventory is the plan's foundation, not a nice extra.&lt;/p&gt;

&lt;h3&gt;
  
  
  Betting on a big-bang rewrite
&lt;/h3&gt;

&lt;p&gt;Freezing the old app and building the new one alongside it for a long time means two systems, a moving target and a single risky cutover day. The business keeps asking for features, and they land in the old app, widening the gap.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; migrate incrementally. Run old and new side by side (the strangler-fig pattern) and move one route or screen at a time, so each step ships to real users.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“[Rewriting the code from scratch is] the single worst strategic mistake that any software company can make.” — &lt;strong&gt;Joel Spolsky&lt;/strong&gt;, &lt;a href="https://www.joelonsoftware.com/2000/04/06/things-you-should-never-do-part-i/" rel="noopener noreferrer"&gt;Things You Should Never Do, Part I&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9ew7hnuec8ngpqx11dw2.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9ew7hnuec8ngpqx11dw2.png" alt="Line chart, modeled: incremental migration puts screens live on the new stack steadily from early in the project, while a big-bang rewrite has 0% live until a single cutover near the end. The area between the lines is value delivered and risk retired early" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  Rewriting when you meant to migrate
&lt;/h3&gt;

&lt;p&gt;"While we're in there" turns a migration into a redesign. New UX, new data model and new framework all at once means nobody can tell whether a difference is a bug or a feature.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; migrate first, with parity as the goal. Improve afterwards, on a stack that's now easier to change. Record any deliberate change in a decisions log.&lt;/p&gt;

&lt;h2&gt;
  
  
  Build mistakes
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Porting without tests that pin down today's behavior
&lt;/h3&gt;

&lt;p&gt;Legacy apps rarely have good tests, so teams port and then click around to check. That misses edge cases: empty states, errors, slow responses, permissions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; write characterization tests from the old code before porting. Run them against the old app first, then against the new one. Lock them once they pass.&lt;/p&gt;

&lt;h3&gt;
  
  
  Mixing refactoring and porting in one change
&lt;/h3&gt;

&lt;p&gt;A pull request that moves a component to React &lt;em&gt;and&lt;/em&gt; renames its props &lt;em&gt;and&lt;/em&gt; restructures its state can't be reviewed for parity. Reviewers end up approving on trust.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; keep port changes and improvement changes separate. Each one should be small enough to judge in a single pass.&lt;/p&gt;

&lt;h3&gt;
  
  
  Ignoring hidden wiring
&lt;/h3&gt;

&lt;p&gt;The dangerous behavior in legacy apps lives outside the obvious files: global listeners, mixins, server-rendered data islands, analytics hooks, CSS that depends on DOM order, timers that assume a page reload.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; make hidden wiring its own inventory section, and give every item an owner and a destination in the new app before the unit that depends on it is ported.&lt;/p&gt;

&lt;h3&gt;
  
  
  Letting AI agents port with no gates
&lt;/h3&gt;

&lt;p&gt;Agents produce code fast and with confidence. Without gates, that just means plausible-looking bugs arrive faster. An agent that reviews its own output mostly agrees with itself.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; put agents inside a process. Use a shared conventions file, small units, locked tests, and a separate reviewer agent that sees only the old code, the new code and the test results. Nothing merges on the porter's word.&lt;/p&gt;

&lt;p&gt;A related trap is running one model for every job. Different stages need different strengths: deep reasoning for planning, speed and volume for porting, and a second model family for review so the checker doesn't share the porter's blind spots.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpeg2wem972nrfifs03kh.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpeg2wem972nrfifs03kh.png" alt="Illustrative model mix by phase. Plan: Fable 5.1 35%, Opus 5.5 50%, Haiku 5.5 15%. Build port and test: Opus 5.5 10%, Sonnet 5.5 80%, Haiku 5.5 10%. Build review and verify: GPT-6 Astra 55%, Opus 5.5 15%, Haiku 5.5 20%, GPT-6 Luna 10%. Ship checks: Sonnet 5.5 45%, Haiku 5.5 35%, GPT-6 Luna 20%" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Automation applied to an efficient operation will magnify the efficiency. Automation applied to an inefficient operation will magnify the inefficiency.” — &lt;strong&gt;Bill Gates&lt;/strong&gt;, &lt;a href="https://en.wikipedia.org/wiki/The_Road_Ahead_%28Gates_book%29" rel="noopener noreferrer"&gt;The Road Ahead&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Shipping mistakes
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkvkc3sm40empdjfeui3u.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkvkc3sm40empdjfeui3u.png" alt="Bar chart, illustrative relative scale: a mistake found in planning costs 1x to fix, while porting 2x, in QA 5x, at cutover 10x, and in production 30x" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  No rollback path
&lt;/h3&gt;

&lt;p&gt;Teams cut over and delete the old route the same day. When something breaks, the only way back is a revert and a redeploy under pressure.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; put each migrated route behind a flag or a routing switch. Roll out to a small share of traffic, watch errors and key metrics, and keep the old path working until the new one has run cleanly for a while.&lt;/p&gt;

&lt;h3&gt;
  
  
  Cutting over without parity data
&lt;/h3&gt;

&lt;p&gt;"It looks right" is not evidence. Without numbers, teams can't say whether the new checkout converts the same, loads as fast or sends the same requests.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; decide the parity signals up front: error rates, performance, key conversion steps, API call patterns, visual diffs. Compare old and new on those before widening a rollout.&lt;/p&gt;

&lt;h3&gt;
  
  
  Declaring done too early
&lt;/h3&gt;

&lt;p&gt;The last 10% (the old build pipeline, the dead dependencies, the compatibility shim, the two screens nobody uses) gets dropped when the team moves on. Two years later you're running both frameworks for good.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do this instead:&lt;/strong&gt; define "done" as the old framework fully removed from the bundle, the build and the dependency list. Track it in the plan from day one, and don't close the project until it's true.&lt;/p&gt;

&lt;h2&gt;
  
  
  Warning signs your project is drifting
&lt;/h2&gt;

&lt;p&gt;These mistakes rarely announce themselves. Watch for the symptoms instead:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Estimates keep growing as the team "discovers" screens, integrations or global code nobody listed.&lt;/li&gt;
&lt;li&gt;The share of the app live on the new stack hasn't moved in weeks, even though plenty of code is being written.&lt;/li&gt;
&lt;li&gt;Bug reports after each release are about things that "used to work".&lt;/li&gt;
&lt;li&gt;Reviews are approved quickly because nobody can tell what changed.&lt;/li&gt;
&lt;li&gt;New features are still being built in the old app.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Any two of these together usually point back to a missing inventory, missing characterization tests or a big-bang plan in disguise.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where AI agents change the picture
&lt;/h2&gt;

&lt;p&gt;AI agents make several of these mistakes cheaper to avoid. An inventory that used to take weeks of reading is now a read-only agent run. Characterization tests that nobody had time to write can be generated from the old code and checked against it. A second reviewer is always available.&lt;/p&gt;

&lt;p&gt;They also make some mistakes faster to make. Agents will happily do a big-bang rewrite, mix refactoring into a port, or edit a failing test until it passes. The process around them, with small units, locked tests and an independent reviewer, matters more with agents, not less.&lt;/p&gt;

&lt;h2&gt;
  
  
  The pattern behind all ten
&lt;/h2&gt;

&lt;p&gt;Almost every mistake here is a planning or verification shortcut that saves a few days early and costs far more later. The fix is consistent: inventory first, move in small units, verify parity with evidence, and keep a way back.&lt;/p&gt;

&lt;p&gt;That's the workflow our &lt;strong&gt;MigrateX&lt;/strong&gt; plugins encode for Angular, AngularJS, Backbone and Ember to React migrations: a read-only inventory, a written plan and unit map, unit-by-unit porting, and an independent parity reviewer on every piece before the old code goes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pre-flight checklist
&lt;/h2&gt;

&lt;p&gt;Before the first unit is ported, check that you can tick every line:&lt;/p&gt;

&lt;h2&gt;
  
  
  Checklist
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Full inventory, including hidden wiring, before any plan or estimate.&lt;/li&gt;
&lt;li&gt;Incremental, strangler-fig migration instead of a big-bang rewrite.&lt;/li&gt;
&lt;li&gt;Parity first, improvements after, with deliberate changes logged.&lt;/li&gt;
&lt;li&gt;Characterization tests written from the old code and locked.&lt;/li&gt;
&lt;li&gt;Small, single-purpose changes; agents behind gates with an independent reviewer.&lt;/li&gt;
&lt;li&gt;Flags and rollback for every cutover, judged on parity data.&lt;/li&gt;
&lt;li&gt;Done means the old framework is gone.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Related reading:&lt;/strong&gt; &lt;a href="https://cobuildx.ai/blog/multi-agent-modernization" rel="noopener noreferrer"&gt;how multi-agent AI speeds up application migration&lt;/a&gt;, &lt;a href="https://cobuildx.ai/blog/ai-agents-qa-team-modernization" rel="noopener noreferrer"&gt;a migration testing strategy with AI agents&lt;/a&gt; and &lt;a href="https://cobuildx.ai/blog/software-migration-lessons-shopify" rel="noopener noreferrer"&gt;software migration lessons from Shopify's AI rewrite&lt;/a&gt;.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/modernization-mistakes-to-avoid" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>legacy</category>
      <category>migration</category>
      <category>softwareengineering</category>
      <category>ai</category>
    </item>
    <item>
      <title>Techniques for Making AI Agents Your QA Team for Reliable Modernization</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Tue, 03 Nov 2026 12:27:34 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/techniques-for-making-ai-agents-your-qa-team-for-reliable-modernization-10ho</link>
      <guid>https://dev.to/cobuildx-ai/techniques-for-making-ai-agents-your-qa-team-for-reliable-modernization-10ho</guid>
      <description>&lt;p&gt;&lt;em&gt;Agents can port a legacy screen in minutes, so the bottleneck moves to proving the new code behaves like the old. These are the techniques that turn agents into a QA team you can trust: layered gates, characterization tests, maker-checker review and visual diffs.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;AI agents can now port a legacy screen in minutes. That moves the bottleneck. The hard question in a legacy system migration is no longer "can we write the new code?" but "how do we know it behaves exactly like the old code?"&lt;/p&gt;

&lt;p&gt;Manual QA can't keep up with agent-speed porting, and a passing build proves very little. The answer is to point agents at verification too, and to set them up so they find problems instead of approving them. Here are the techniques that make an agent QA team you can trust.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why migration testing is different
&lt;/h2&gt;

&lt;p&gt;Normal QA asks whether software meets a spec. Modernization QA asks whether the new system matches the old one, and the old one usually has no spec. Its real behavior is spread across templates, watchers, global events, server quirks and years of bug fixes nobody wrote down.&lt;/p&gt;

&lt;p&gt;So the goal is &lt;strong&gt;parity&lt;/strong&gt;: same outputs, same side effects, same edge cases, unless a difference is a deliberate, recorded decision. Every technique below serves that goal.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Program testing can be used to show the presence of bugs, but never to show their absence.” — &lt;strong&gt;Edsger W. Dijkstra&lt;/strong&gt;, &lt;a href="https://www.cs.utexas.edu/~EWD/transcriptions/EWD02xx/EWD249.html" rel="noopener noreferrer"&gt;Notes on Structured Programming&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Technique 1: Five layers, cheapest first
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkvdokc5xf9cc5nrjx92j.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkvdokc5xf9cc5nrjx92j.png" alt="Five QA layers from cheapest to most expensive: static gates, characterization tests, behavior parity review, visual and end-to-end diff, and human sign-off on a risk-ranked sample" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Don't send every change to the most expensive check. Stack the gates so cheap, deterministic checks catch the obvious problems before an agent or a person spends time on them:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Static gates.&lt;/strong&gt; Types, lint, build, and a banned-API list (no jQuery in the React tree, no direct DOM access, no old global stores).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Characterization tests.&lt;/strong&gt; Tests that record what the old code does today, written before the port.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Behavior parity review.&lt;/strong&gt; A separate agent compares old and new logic and reports differences.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Visual and end-to-end diff.&lt;/strong&gt; Screenshots, user flows and network calls, old against new.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Human sign-off.&lt;/strong&gt; People review a risk-ranked sample, not every line.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Nothing merges on the porter's word. Each layer is a gate, and a failure sends the unit back.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwtmvlv6ypkvb90xs4yh1.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwtmvlv6ypkvb90xs4yh1.png" alt="Bar chart of the modeled share of behavior bugs reaching production as layers stack: 100% with no gates, 70% after static gates, 28% after characterization tests, 14% after the parity review agent, 8.4% after visual and E2E diff, 5.9% after a human risk sample" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;No single layer is close to perfect, and none needs to be. With modest catch rates for each layer, the model above lets through about 6% of behavior bugs, against 28% when you stop at tests. The layers only multiply like this when they look at different things, which is why each one has a distinct job.&lt;/p&gt;

&lt;h2&gt;
  
  
  Technique 2: Write characterization tests before the port
&lt;/h2&gt;

&lt;p&gt;Have a test-writer agent read the &lt;strong&gt;old&lt;/strong&gt; unit and write tests that pin down its current behavior: rendered output for known inputs, events fired, API calls made, validation messages shown, what happens on empty, error and slow responses. These tests run against the old code first and must pass there.&lt;/p&gt;

&lt;p&gt;Then the same tests run against the new code. Because they were written from the original, not from the port, they can't inherit the porter's misunderstandings.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Lock the tests once they pass on the old code. If a porter edits a characterization test to make it pass, that is a finding, not a fix.&lt;/p&gt;

&lt;p&gt;“To me, legacy code is simply code without tests.” — &lt;strong&gt;Michael Feathers&lt;/strong&gt;, &lt;a href="https://www.oreilly.com/library/view/working-effectively-with/0131177052/" rel="noopener noreferrer"&gt;Working Effectively with Legacy Code&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Technique 3: Maker and checker never share a context
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpdpuqrnkcx0iorqnvnge.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpdpuqrnkcx0iorqnvnge.png" alt="The porter agent writes new code and sends the diff and test results to a reviewer agent that sees only old code, new code and tests. The reviewer returns findings with file, line and scenario, looping until there are no confirmed findings or a human breaks the tie" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;An agent reviewing its own work mostly agrees with itself. It already has a story for why every line is right. The reviewer has to be a separate agent with a fresh context that sees only the evidence: the original code, the new code and the test output.&lt;/p&gt;

&lt;p&gt;Give the reviewer a narrow job and a strict output format. Ask for concrete findings, each with a file, a line and a failing scenario, and nothing else:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Compare src/legacy/orders/OrderList.js with src/app/orders/OrderList.tsx.
Report only behavior differences a user or API consumer could observe.
For each: file:line, the input or scenario, old result, new result.
Do not comment on style. Do not suggest refactors.
If you find none, say so.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Run a second pass on the findings themselves. A verifier agent tries to reproduce each one, and only confirmed findings go back to the porter. This keeps false alarms from wasting porter time and teaching the team to ignore the reviewer.&lt;/p&gt;

&lt;p&gt;The same logic applies to choosing models for each layer. Use a different model family for the reviewer than for the code it checks, put cheap fast models on high-volume checks, and keep top-tier models for the judgment calls.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fu4nd12c037fvi9yq5cim.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fu4nd12c037fvi9yq5cim.png" alt="Bar chart of an example setup, agent calls per migrated unit by QA layer: static gates use no model, characterization tests 1 call on Sonnet 5.5, behavior parity review 1.3 calls on GPT-6 Astra, visual and E2E diff 2 calls on Sonnet 5.5, finding verifier 1.5 calls on Haiku 5.5, human sign-off prep 0.2 calls on Opus 5.5" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Technique 4: Diff what the user sees and what the server sees
&lt;/h2&gt;

&lt;p&gt;Logic review misses things a user notices immediately: a shifted layout, a missing loading spinner, a date in the wrong format. An agent driving a browser can run the same flow on the old and new app, take screenshots at each step and compare them.&lt;/p&gt;

&lt;p&gt;Record network traffic too. If the old screen made three API calls with certain parameters and the new one makes five, or drops a header, something changed. Network diffs catch problems that never show up on screen until production traffic hits them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Technique 5: Spend human time where risk is highest
&lt;/h2&gt;

&lt;p&gt;Agents make human review cheaper, not unnecessary. Have the orchestrator rank units by risk: payments, auth, permissions, data writes and anything with a history of incidents go first. People review those in full, and a sample of the rest.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fr21rezcvtn6sm4seowu4.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fr21rezcvtn6sm4seowu4.png" alt="Grouped bar chart of modeled human review hours for 200 units. Reviewing every unit takes 400 hours. Risk-ranked review takes 124 hours: 80 for all high-risk units, 24 for a 20% sample of medium, 20 for a 10% sample of low" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;In this model, risk ranking cuts senior review time by about two thirds while still reviewing every high-risk unit in full. Agents run the first four layers on every unit regardless.&lt;/p&gt;

&lt;p&gt;Every deliberate difference, such as a bug you chose to fix instead of copying, goes into a decisions log with a reason. When parity tests fail later, the log tells the reviewer which differences are expected.&lt;/p&gt;

&lt;h2&gt;
  
  
  Technique 6: Measure the QA team itself
&lt;/h2&gt;

&lt;p&gt;An agent QA team needs QA too. Seed a few known bugs into ported units, such as a dropped validation rule, a changed sort order or a missing error state, and check that the layers catch them. If a seeded bug slips through, you know which layer to strengthen before a real one does.&lt;/p&gt;

&lt;p&gt;Track the reviewer's precision as well: the share of its findings that the verifier confirms. A reviewer that cries wolf gets ignored, and a reviewer that never finds anything is probably not looking hard enough. Both numbers belong on the project dashboard next to units migrated.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Seeded-bug catch rate:&lt;/strong&gt; which layer caught each planted defect, and which missed it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reviewer precision:&lt;/strong&gt; confirmed findings divided by all findings.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escaped defects:&lt;/strong&gt; bugs found after merge, traced back to the layer that should have caught them.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What this looks like in MigrateX
&lt;/h2&gt;

&lt;p&gt;Our MigrateX plugins build this in. Each framework plugin has a read-only &lt;strong&gt;parity-reviewer&lt;/strong&gt; agent that checks one migrated piece against its original for behavior, markup, data and timing differences before the old code is removed. It can't edit code, so it can only report. The porter fixes, the reviewer checks again, and an engineer signs off.&lt;/p&gt;

&lt;h2&gt;
  
  
  Key takeaways
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Modernization QA is about parity with an undocumented system, not meeting a spec.&lt;/li&gt;
&lt;li&gt;Stack gates from cheap to expensive: static checks, characterization tests, parity review, visual and network diffs, human sign-off.&lt;/li&gt;
&lt;li&gt;Write tests from the old code before the port, and lock them.&lt;/li&gt;
&lt;li&gt;Keep the reviewer in a separate context, ask for concrete findings, and verify findings before acting on them.&lt;/li&gt;
&lt;li&gt;Spend human review on the riskiest units, and log every deliberate difference.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Related reading:&lt;/strong&gt; &lt;a href="https://cobuildx.ai/blog/multi-agent-modernization" rel="noopener noreferrer"&gt;how multi-agent AI speeds up application migration&lt;/a&gt;, &lt;a href="https://cobuildx.ai/blog/modernization-mistakes-to-avoid" rel="noopener noreferrer"&gt;10 legacy modernization mistakes to avoid&lt;/a&gt; and &lt;a href="https://cobuildx.ai/blog/software-migration-lessons-shopify" rel="noopener noreferrer"&gt;software migration lessons from Shopify's AI rewrite&lt;/a&gt;.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/ai-agents-qa-team-modernization" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>testing</category>
      <category>migration</category>
      <category>agents</category>
    </item>
    <item>
      <title>10x Your Modernization Efforts With Multi-Agent Teams</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Tue, 03 Nov 2026 12:26:29 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/10x-your-modernization-efforts-with-multi-agent-teams-16pd</link>
      <guid>https://dev.to/cobuildx-ai/10x-your-modernization-efforts-with-multi-agent-teams-16pd</guid>
      <description>&lt;p&gt;&lt;em&gt;One agent porting one file at a time stalls fast. Teams getting big gains split the work across an orchestrator, parallel porters, a test writer and an independent reviewer. Here is how that setup works and where the speed-up really comes from.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Most teams try AI on an application migration the same way: one chat, one agent, one file at a time. It works for a demo. Then the codebase turns out to have 400 components, a router nobody fully understands and a service layer with side effects in every getter, and the single agent becomes the bottleneck. It forgets what it ported yesterday, repeats the same mistakes, and marks its own homework.&lt;/p&gt;

&lt;p&gt;The teams getting large gains don't use a smarter agent. They use &lt;strong&gt;more agents with narrower jobs&lt;/strong&gt;, coordinated around a plan. This post covers how that setup works, where the speed-up really comes from, and what has to be true before you get anything close to 10x.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why one agent stalls
&lt;/h2&gt;

&lt;p&gt;A single agent doing a migration carries the whole project in one context window: the old code, the new code, the conventions, the test output and its own earlier decisions. As the window fills, quality drops. It starts to drift from conventions it set itself, and it re-reads files it already understood.&lt;/p&gt;

&lt;p&gt;It also works in series. Port, test, fix, review, then the next unit. Even if each step is fast, the project's speed is the sum of every step.&lt;/p&gt;

&lt;p&gt;And when the same agent that wrote the code reviews it, it mostly agrees with itself. The bugs that matter most in a migration, small behavior differences between old and new, are exactly the ones its own reasoning has already explained away.&lt;/p&gt;

&lt;h2&gt;
  
  
  The multi-agent setup for application migration
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4ud8236sva3equebxuis.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4ud8236sva3equebxuis.png" alt="An orchestrator holding the unit graph and work queue sends work to an inventory agent, two porter agents and a test-writer agent. All of them hand results to an independent parity reviewer, and anything that fails goes back to the queue" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;A working setup has five roles. Each is an agent with its own context, its own instructions and a narrow set of tools.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Orchestrator.&lt;/strong&gt; Owns the plan: the list of units, their dependencies and their status. It hands out work and never writes app code.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Inventory agent.&lt;/strong&gt; Read-only. Maps every route, component, service, global and hidden wiring point before anyone writes a line. Its output is the unit graph.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Porters.&lt;/strong&gt; Each takes one unit at a time and moves it to the target stack, following a shared conventions file. Several run at once.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Test writer.&lt;/strong&gt; Captures what the old unit does today, as characterization tests, before or alongside the port.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Parity reviewer.&lt;/strong&gt; A fresh agent that sees only the old code, the new code and the test results, and reports concrete differences with a file, line and failing scenario.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;Split by &lt;strong&gt;unit&lt;/strong&gt;, not by step. Give a porter a whole component with its tests, not "all the templates" across the app.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Where the speed-up actually comes from
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fitel7gjvphuwyg2v7p38.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fitel7gjvphuwyg2v7p38.png" alt="Line chart of modeled speed-up against the number of porter agents, using Amdahl's law. With 95% of units independent, 16 porters give about 9.1 times; with 80% about 4.0 times; with 50% about 1.9 times" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The chart above is a simple model (Amdahl's law), but the shape holds on real projects. Parallel porters only help when the units they work on don't depend on each other. If unit 6 needs unit 2's new API, it waits. So the real driver of throughput is the &lt;strong&gt;unit graph&lt;/strong&gt;: how well the inventory step breaks the app into pieces that can move independently.&lt;/p&gt;

&lt;p&gt;The other multiplier is less obvious: &lt;strong&gt;fewer re-dos&lt;/strong&gt;. Each agent's context stays small and focused, so the work is more consistent. The reviewer catches parity bugs while the unit is still fresh, not at user testing three months later. In practice, avoided rework is often worth more than raw parallelism.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foj2ep68129m6eu41pl7g.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foj2ep68129m6eu41pl7g.png" alt="Bar chart of modeled elapsed hours to migrate 120 units: one agent 180 hours, 4 porters and 1 reviewer 84 hours, 8 porters and 1 reviewer still 84 hours because review is the bottleneck, 4 or 8 porters with 2 reviewers 60 hours, 8 porters and 4 reviewers 48 hours" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Review capacity matters just as much. In the model above, doubling porters from four to eight with a single reviewer saves nothing: the reviewer is the bottleneck. Adding reviewers is what moves the number.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Adding manpower to a late software project makes it later.” — &lt;strong&gt;Fred Brooks&lt;/strong&gt;, &lt;a href="https://en.wikipedia.org/wiki/The_Mythical_Man-Month" rel="noopener noreferrer"&gt;The Mythical Man-Month&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Put together, a well-cut graph, several porters and an early independent review can turn a project measured in quarters into one measured in weeks. A badly cut graph with ten agents is just ten agents waiting on each other.&lt;/p&gt;

&lt;h2&gt;
  
  
  Five rules that make it work
&lt;/h2&gt;

&lt;blockquote&gt;
&lt;p&gt;“There is nothing so useless as doing efficiently that which should not be done at all.” — &lt;strong&gt;&lt;a href="https://en.wikipedia.org/wiki/Peter_Drucker" rel="noopener noreferrer"&gt;Peter Drucker&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Inventory before you port.&lt;/strong&gt; No porter starts until the unit graph exists. The graph decides the order, the parallelism and what "done" means.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One shared conventions file.&lt;/strong&gt; Naming, state management, styling, error handling, folder layout. Every porter reads it, and the reviewer checks against it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Small, verifiable units.&lt;/strong&gt; A unit should be portable and reviewable on its own: one route, one component tree, one service. If a reviewer can't judge it in one pass, it's too big.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Maker and checker never share a context.&lt;/strong&gt; The reviewer gets no access to the porter's reasoning, only the evidence.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Durable state outside the agents.&lt;/strong&gt; Unit status, decisions and open findings live in files in the repo, not in any agent's memory. Any agent can be restarted without losing the project.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Which model for which agent
&lt;/h2&gt;

&lt;p&gt;Running one flagship model for every role is the simplest setup, and the most wasteful. Roles need different things. The orchestrator and the inventory agent make the decisions everything else depends on, so they get the deepest reasoning: &lt;strong&gt;Fable 5.1&lt;/strong&gt; or &lt;strong&gt;Opus 5.5&lt;/strong&gt;. Porters and the test writer do high-volume, well-specified work against a conventions file, which is what &lt;strong&gt;Sonnet 5.5&lt;/strong&gt; is good at. Checking whether a finding reproduces is a narrow yes-or-no task for a fast model like &lt;strong&gt;Haiku 5.5&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmiiruvc4sd0xdiymzym2.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmiiruvc4sd0xdiymzym2.png" alt="Bar chart of an example setup, agent calls per migrated unit by role: orchestrator 1 call on Fable 5.1, inventory 0.17 calls on Opus 5.5, porters 3 calls on Sonnet 5.5, test writer 1 call on Sonnet 5.5, parity reviewer 1.3 calls on GPT-6 Astra, finding verifier 1.5 calls on Haiku 5.5, each with an alternative model" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The reviewer is the one place to deliberately switch model families. If Claude models write the code, a reviewer such as OpenAI's &lt;strong&gt;GPT-6 Astra&lt;/strong&gt; is less likely to share their blind spots, and the reverse holds too. Treat the chart as a starting point, not a rule. Swap models per role as you measure what each one gets right on your codebase.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F438jrkavsra4nl1qubr6.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F438jrkavsra4nl1qubr6.png" alt="Modeled share of agent calls for a 120-unit migration. One flagship for every role: Fable 5.1 handles 100% of calls. Tiered by role: Fable 5.1 13%, Opus 5.5 2%, GPT-6 Astra 16%, Sonnet 5.5 50%, Haiku 5.5 19%" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;In this model, tiering moves about 70% of calls to Sonnet 5.5 and Haiku 5.5, while every decision that shapes the project still goes through a top-tier model.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where it goes wrong
&lt;/h2&gt;

&lt;p&gt;Two porters editing the same shared file is the most common failure. Give shared modules (the router, the store, the design system) a single owner, and have porters ask for changes through the orchestrator.&lt;/p&gt;

&lt;p&gt;The second is review becoming the bottleneck. If four porters each produce a unit an hour and the reviewer takes two hours per unit, you've built a queue, not a pipeline. Run more than one reviewer, or keep units small enough to review quickly.&lt;/p&gt;

&lt;p&gt;The third is trusting green checks. A porter can make tests pass by changing the tests. Lock characterization tests once they're written, and treat any change to them as a finding in its own right.&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with a pilot
&lt;/h2&gt;

&lt;p&gt;Don't switch a whole program to multi-agent on day one. Pick one slice of the app, ten to twenty units with a mix of easy and awkward ones, and run the full setup on it: inventory, conventions file, porters, test writer and reviewer.&lt;/p&gt;

&lt;p&gt;Track three numbers during the pilot: how many units pass review first time, how many reviewer findings turn out to be real, and how long units wait in the review queue. The first tells you whether your conventions and unit sizes work. The second tells you whether to trust the reviewer. The third tells you how many reviewers to run before you add porters.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Scale porters only after first-time pass rate and review wait time look healthy. Otherwise you are just making a longer queue.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  How we run it
&lt;/h2&gt;

&lt;p&gt;This is the structure behind &lt;strong&gt;MigrateX&lt;/strong&gt;, our migration toolkit for moving Angular, AngularJS, Backbone and Ember apps to React. Each plugin runs a read-only inventory agent first, writes the plan and unit map into a &lt;code&gt;.migration/&lt;/code&gt; folder in the repo, then ports unit by unit with a separate parity-reviewer agent checking each one against its original before the old code is removed.&lt;/p&gt;

&lt;p&gt;The agents do the volume. Engineers own the plan, the conventions and the final call on anything the reviewer flags. That split, more than any single model, is where the multiplier comes from.&lt;/p&gt;

&lt;h2&gt;
  
  
  Key takeaways
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;One agent doing everything stalls on context, works in series and grades its own work.&lt;/li&gt;
&lt;li&gt;Use an orchestrator, an inventory agent, parallel porters, a test writer and an independent reviewer.&lt;/li&gt;
&lt;li&gt;The speed-up depends on the unit graph and on avoided rework, not on how many agents you run.&lt;/li&gt;
&lt;li&gt;Keep project state in the repo, give shared files one owner, and lock tests once they're written.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Related reading:&lt;/strong&gt; &lt;a href="https://cobuildx.ai/blog/ai-agents-qa-team-modernization" rel="noopener noreferrer"&gt;a migration testing strategy with AI agents&lt;/a&gt;, &lt;a href="https://cobuildx.ai/blog/modernization-mistakes-to-avoid" rel="noopener noreferrer"&gt;10 legacy modernization mistakes to avoid&lt;/a&gt; and &lt;a href="https://cobuildx.ai/blog/software-migration-lessons-shopify" rel="noopener noreferrer"&gt;software migration lessons from Shopify's AI rewrite&lt;/a&gt;.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/multi-agent-modernization" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>migration</category>
      <category>legacy</category>
    </item>
    <item>
      <title>6 Software Migration Lessons from Shopify's 12-Week AI-Assisted Rewrite</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Tue, 03 Nov 2026 12:26:22 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/6-software-migration-lessons-from-shopifys-12-week-ai-assisted-rewrite-4al</link>
      <guid>https://dev.to/cobuildx-ai/6-software-migration-lessons-from-shopifys-12-week-ai-assisted-rewrite-4al</guid>
      <description>&lt;p&gt;&lt;em&gt;A team of six at Shopify moved a major production app to a new stack in 12 weeks, with AI agents doing most of the porting. The lessons apply to any legacy modernization: the old system is the spec, parity is done, and humans approve.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Every engineering team has a migration it keeps postponing. Maybe it's a monolith that should have been split years ago, a framework two major versions behind, a database the business has outgrown, or a language nobody wants to hire for. Everyone agrees it should happen, and nobody wants to pay for it.&lt;/p&gt;

&lt;p&gt;Shopify recently showed how quickly that calculation is changing. A team of six moved a major production app to a new stack in &lt;strong&gt;12 weeks&lt;/strong&gt;, with AI coding agents doing most of the porting (&lt;a href="https://shopify.engineering/shop-app-migration" rel="noopener noreferrer"&gt;read Shopify's post&lt;/a&gt;). Their case was a mobile app, but the lessons have nothing to do with mobile. They apply to any &lt;strong&gt;legacy modernization&lt;/strong&gt; project, whether that's a backend, a data platform or an internal tool.&lt;/p&gt;

&lt;p&gt;Here's what we took from it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fri13yxmvgwa4vez3cutl.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fri13yxmvgwa4vez3cutl.png" alt="Six lessons from Shopify's migration: revisit the shelved migration, the old system is the spec, parity is done, humans approve, parallel lanes, simplify as you go" width="800" height="300"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Revisit the migration you shelved, because the cost has changed
&lt;/h2&gt;

&lt;p&gt;Shopify didn't migrate because the old system broke. They migrated because AI agents changed what it would cost to move. A rewrite that couldn't be justified a year ago became a 12-week project.&lt;/p&gt;

&lt;p&gt;Most &lt;strong&gt;migration strategy&lt;/strong&gt; discussions take the cost of moving as a given. It isn't anymore. If your team ruled out a migration as "too expensive" more than a year ago, it's worth asking again.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Your legacy system is the spec
&lt;/h2&gt;

&lt;p&gt;Shopify found that agents work best when there's an existing implementation to use as a reference. That's the hidden advantage of migrations over new builds. You aren't asking AI to guess what to build. You're asking it to reproduce behavior that already exists, runs in production and has years of edge cases baked in.&lt;/p&gt;

&lt;p&gt;Shopify's process started with &lt;strong&gt;documenting how the old system behaved&lt;/strong&gt; (its UI, state, data flows, analytics and accessibility) before writing any new code. Every &lt;strong&gt;software migration&lt;/strong&gt; should start the same way: build an inventory of what the legacy system actually does, not what the documentation says it does. That inventory is what you test the new system against.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“To me, legacy code is simply code without tests.” — &lt;strong&gt;Michael Feathers&lt;/strong&gt;, &lt;a href="https://www.oreilly.com/library/view/working-effectively-with/0131177052/" rel="noopener noreferrer"&gt;Working Effectively with Legacy Code&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  3. Parity is the definition of done
&lt;/h2&gt;

&lt;p&gt;This is the most important lesson, and the one most teams skip. Shopify built an internal tool that captured outputs from &lt;strong&gt;both&lt;/strong&gt; the old and new systems at named checkpoints. Agents then compared them automatically, ignoring expected noise like timestamps and IDs.&lt;/p&gt;

&lt;p&gt;Generated code that &lt;em&gt;looks&lt;/em&gt; right isn't the goal. The goal is a new system that &lt;em&gt;behaves&lt;/em&gt; like the old one, including the parts nobody remembers to test:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Events and data feeds that downstream systems depend on&lt;/li&gt;
&lt;li&gt;Users and sessions that carry across without interruption&lt;/li&gt;
&lt;li&gt;Integrations, notifications and background jobs&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Shopify treated their analytics events as a contract, because other systems relied on them. Every &lt;strong&gt;legacy system migration&lt;/strong&gt; has contracts like that, and most aren't written down. Parity checks are the best &lt;strong&gt;risk mitigation&lt;/strong&gt; you have: without them, an AI migration just moves the risk somewhere else.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Code that looks right isn't done. A new system that behaves like the old one, checked with evidence, is.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwogjvvqf8cz34yuq1ezk.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwogjvvqf8cz34yuq1ezk.png" alt="Parity check flow: old and new systems produce outputs at named checkpoints, outputs are normalized to drop timestamps and IDs, then compared; a match passes and a diff goes back for a fix" width="800" height="300"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody.” — &lt;strong&gt;Hyrum Wright&lt;/strong&gt;, &lt;a href="https://www.hyrumslaw.com/" rel="noopener noreferrer"&gt;Hyrum's Law&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  4. Humans approve, agents execute
&lt;/h2&gt;

&lt;p&gt;Shopify didn't let agents run unchecked. Engineers reviewed requirements and plans before any code was written, and each approval was &lt;strong&gt;tied to a content hash&lt;/strong&gt;. If the plan changed, the approval was voided automatically.&lt;/p&gt;

&lt;p&gt;They also kept experienced engineers reviewing the output, because generated code could meet every requirement and still add duplication, architectural drift or performance problems.&lt;/p&gt;

&lt;p&gt;That's the right split for any serious &lt;strong&gt;application migration&lt;/strong&gt;. Agents bring speed and scale. People own the decisions, the quality bar and the sign-off, and every change can be traced back to an approved plan.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsirzrcjpxi1rp0b4e7ap.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsirzrcjpxi1rp0b4e7ap.png" alt="Content-hash approvals: plan v1 hashes to a91f, an engineer approves a91f and agents execute; when the plan is edited its hash changes to 7c2e, the approval is void and the plan goes back for review" width="800" height="300"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Parallelize the work, but keep the feedback loop fast
&lt;/h2&gt;

&lt;p&gt;Shopify ran many agent sessions at once, each in its own git worktree, instead of making one change at a time. They also gave agents direct access to the running system's logs, events and state, so agents could check their own work.&lt;/p&gt;

&lt;p&gt;The pattern carries over to any migration:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Split the work into independent lanes (modules, services or features).&lt;/li&gt;
&lt;li&gt;Give each lane a clear, approved task definition.&lt;/li&gt;
&lt;li&gt;Give agents a fast way to build, test and observe the result.&lt;/li&gt;
&lt;li&gt;Review often.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The bottleneck moves from typing code to defining tasks well and reviewing results quickly. Plan your team's time around that.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb3pi5jnjpaznbrylp1fo.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb3pi5jnjpaznbrylp1fo.png" alt="Parallel lanes: approved task definitions feed lanes A, B and C, each in its own git worktree with a build, test and observe loop, then human review, then merge" width="800" height="300"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Migrate and simplify at the same time
&lt;/h2&gt;

&lt;p&gt;Shopify didn't port everything one to one. They retired some screens and simplified others. A migration is the cheapest chance you'll ever get to drop dead code, unused features and accidental complexity, since you're touching everything anyway. Decide what &lt;em&gt;not&lt;/em&gt; to migrate before you start.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.” — &lt;strong&gt;Antoine de Saint-Exupéry&lt;/strong&gt;, &lt;a href="https://en.wikipedia.org/wiki/Wind,_Sand_and_Stars" rel="noopener noreferrer"&gt;Wind, Sand and Stars&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  What's still missing: the last mile of a software migration
&lt;/h2&gt;

&lt;p&gt;Shopify's post focuses on building and verifying the new system. It says little about feature flags, gradual rollout or rollback, which is where many migrations actually fail.&lt;/p&gt;

&lt;p&gt;At &lt;strong&gt;MigrateX&lt;/strong&gt;, we see a migration as everything from understanding the old system to safely retiring it:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Discover&lt;/strong&gt; what the legacy system really does&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan&lt;/strong&gt; the migration, with human approval&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Migrate&lt;/strong&gt; in parallel lanes with AI agents&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Verify&lt;/strong&gt; parity against the original&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Roll out&lt;/strong&gt; gradually, with rollback ready&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F21ufzl79izmubduxz9ju.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F21ufzl79izmubduxz9ju.png" alt="Illustrative gradual rollout: the new system ships behind a flag, then 1%, 10%, 50% and 100% of traffic, then the old system is retired; if parity or error signals are off at any step, traffic rolls back to the old path" width="800" height="300"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The takeaway
&lt;/h2&gt;

&lt;p&gt;AI can turn a multi-quarter migration into a matter of weeks. But Shopify's speed came from &lt;strong&gt;discipline, not just code generation&lt;/strong&gt;: they treated the old system as the spec, proved parity, gated plans and kept humans on review.&lt;/p&gt;

&lt;p&gt;That discipline is what we're building into MigrateX. &lt;strong&gt;Have a migration you've been putting off?&lt;/strong&gt; &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;Talk to us about a migration feasibility sprint&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Key takeaways
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;AI agents have changed the cost of migrating, so re-check the migrations you shelved.&lt;/li&gt;
&lt;li&gt;Inventory what the old system actually does; that inventory is the spec.&lt;/li&gt;
&lt;li&gt;Done means behavioral parity, proven with side-by-side checks, not code that looks right.&lt;/li&gt;
&lt;li&gt;Engineers approve plans and review output; agents do the volume in parallel lanes.&lt;/li&gt;
&lt;li&gt;Plan the rollout and rollback, not just the rewrite.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;Source: Shopify Engineering, &lt;a href="https://shopify.engineering/shop-app-migration" rel="noopener noreferrer"&gt;Shop app migration&lt;/a&gt;. Figures are from Shopify's post.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Related reading:&lt;/strong&gt; &lt;a href="https://cobuildx.ai/blog/multi-agent-modernization" rel="noopener noreferrer"&gt;how multi-agent AI speeds up application migration&lt;/a&gt;, &lt;a href="https://cobuildx.ai/blog/ai-agents-qa-team-modernization" rel="noopener noreferrer"&gt;a migration testing strategy with AI agents&lt;/a&gt; and &lt;a href="https://cobuildx.ai/blog/modernization-mistakes-to-avoid" rel="noopener noreferrer"&gt;10 legacy modernization mistakes to avoid&lt;/a&gt;.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/software-migration-lessons-shopify" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>migration</category>
      <category>softwareengineering</category>
      <category>legacy</category>
    </item>
    <item>
      <title>Introducing PII Extractor: A Lightweight Model for PII Extraction at Warp Speed</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Thu, 29 Oct 2026 05:12:16 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/introducing-pii-extractor-a-lightweight-model-for-pii-extraction-at-warp-speed-59ga</link>
      <guid>https://dev.to/cobuildx-ai/introducing-pii-extractor-a-lightweight-model-for-pii-extraction-at-warp-speed-59ga</guid>
      <description>&lt;p&gt;Three open models, from 17M to 68M parameters, built for a single job: finding personal information in text accurately enough for production and fast enough to run on every request.&lt;/p&gt;

&lt;h2&gt;
  
  
  Highlights
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;88.3% F1 on Privacy-Bench&lt;/strong&gt;, a benchmark of human-annotated business documents, with a 68M-parameter model. PII-Tracer (596M) scores 86.5%, GLiNER2-PII (205M) 83.7% and nvidia GLiNER-PII (570M) 66.4%.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The smallest model, at 17M parameters, is within half a point of PII-Tracer&lt;/strong&gt; at 1/35 of its size.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;37% fewer false alarms than PII-Tracer&lt;/strong&gt; while finding almost as much personal data.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;12 types of PII&lt;/strong&gt;, from names and emails to government IDs, secrets and IP addresses.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Openly available&lt;/strong&gt; on Hugging Face under Apache-2.0: &lt;a href="https://huggingface.co/CobuildX-AI/cbx-pii-extractor-68M" rel="noopener noreferrer"&gt;pii-extractor-68M&lt;/a&gt;, &lt;a href="https://huggingface.co/CobuildX-AI/cbx-pii-extractor-32M" rel="noopener noreferrer"&gt;pii-extractor-32M&lt;/a&gt; and &lt;a href="https://huggingface.co/CobuildX-AI/cbx-pii-extractor-17M" rel="noopener noreferrer"&gt;pii-extractor-17M&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Every message sent to an LLM, every document added to a search index and every support ticket written to a log raises the same question: &lt;em&gt;does this contain personal information, and exactly where?&lt;/em&gt; The check runs on every request, so its speed and cost set the floor for everything behind it. Yet the strongest PII detectors available today carry hundreds of millions of parameters, and general-purpose LLMs carry far more.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;PII Extractor&lt;/strong&gt; is a family of three compact models purpose-built to extract personal data from the text you send it, and light enough to fine-tune for your own use case. At 68M parameters, it is the most accurate PII detector we tested on real business documents. At 17M, it processes 1,000 tokens in 0.17 seconds on four CPU threads, with no GPU at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why PII detection belongs in a small model
&lt;/h2&gt;

&lt;p&gt;Finding PII is not open-ended generation. A model reads a text once and decides, for every word, whether it belongs to a name, an email address, an account number or nothing at all. The answer is a set of character positions that can be redacted, masked or routed.&lt;/p&gt;

&lt;p&gt;That makes it a natural fit for a small encoder. An encoder reads the whole text in both directions at once, so every word is judged in its full context: in "Will will sign the contract on Monday", the first "Will" is a name and the second is not. There is no text to generate and no output to parse, and the cost of a call depends only on the length of the input.&lt;/p&gt;

&lt;h2&gt;
  
  
  Meet PII Extractor
&lt;/h2&gt;

&lt;p&gt;PII Extractor is fine-tuned from Ettin [6], an open encoder family from Johns Hopkins University with an architecture similar to ModernBERT [7]. The three models are built on Ettin-68M, Ettin-32M and Ettin-17M.&lt;/p&gt;

&lt;p&gt;Each model reads up to 8K tokens in a single pass, splits longer texts automatically, and returns every piece of personal data with its exact position and one of 12 types:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Type&lt;/th&gt;
&lt;th&gt;What it covers&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;PERSON&lt;/td&gt;
&lt;td&gt;Names, including first names alone, initials and nicknames&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EMAIL&lt;/td&gt;
&lt;td&gt;Email addresses, including written-out forms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PHONE&lt;/td&gt;
&lt;td&gt;Phone and fax numbers&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ADDRESS&lt;/td&gt;
&lt;td&gt;Street addresses; a city or country on its own is not labelled&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DATE&lt;/td&gt;
&lt;td&gt;Dates of birth&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;URL&lt;/td&gt;
&lt;td&gt;Web addresses, with or without &lt;code&gt;https://&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ACCOUNT_NUMBER&lt;/td&gt;
&lt;td&gt;Bank, card, IBAN and customer account numbers&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GOV_ID&lt;/td&gt;
&lt;td&gt;Social security, passport, national ID, tax ID and driving licence numbers&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;USERNAME&lt;/td&gt;
&lt;td&gt;Usernames and handles&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SECRET&lt;/td&gt;
&lt;td&gt;Passwords, PINs, access codes, API keys and tokens&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;IP_ADDRESS&lt;/td&gt;
&lt;td&gt;IPv4 and IPv6 addresses&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;OTHER_ID&lt;/td&gt;
&lt;td&gt;Employee, patient, member and device IDs&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Leading accuracy on business documents
&lt;/h2&gt;

&lt;p&gt;On Privacy-Bench, 656 pages of real business documents annotated by people, PII Extractor-68M scores 88.3% F1, ahead of PII-Tracer at 86.5%, GLiNER2-PII at 83.7% and nvidia GLiNER-PII at 66.4%. PII Extractor-32M also scores above all three, at 18× smaller than PII-Tracer.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Faj0zbrkz3ooqvx0gzaho.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Faj0zbrkz3ooqvx0gzaho.png" alt="Privacy-Bench F1 by model" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Model&lt;/th&gt;
&lt;th&gt;Size&lt;/th&gt;
&lt;th&gt;Privacy-Bench&lt;/th&gt;
&lt;th&gt;PII-TRACE&lt;/th&gt;
&lt;th&gt;GPU, 1,000 tokens&lt;/th&gt;
&lt;th&gt;CPU, 1,000 tokens&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;PII Extractor-68M&lt;/td&gt;
&lt;td&gt;68M&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;88.3%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;82.4%&lt;/td&gt;
&lt;td&gt;23 ms&lt;/td&gt;
&lt;td&gt;1.17 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PII Extractor-32M&lt;/td&gt;
&lt;td&gt;32M&lt;/td&gt;
&lt;td&gt;87.5%&lt;/td&gt;
&lt;td&gt;84.6%&lt;/td&gt;
&lt;td&gt;16 ms&lt;/td&gt;
&lt;td&gt;0.40 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PII Extractor-17M&lt;/td&gt;
&lt;td&gt;17M&lt;/td&gt;
&lt;td&gt;86.0%&lt;/td&gt;
&lt;td&gt;81.2%&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;15 ms&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0.17 s&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PII-Tracer [3]&lt;/td&gt;
&lt;td&gt;596M&lt;/td&gt;
&lt;td&gt;86.5%&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;92.6%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;271 ms&lt;/td&gt;
&lt;td&gt;9.15 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GLiNER2-PII [4]&lt;/td&gt;
&lt;td&gt;205M&lt;/td&gt;
&lt;td&gt;83.7%&lt;/td&gt;
&lt;td&gt;62.2%&lt;/td&gt;
&lt;td&gt;199 ms&lt;/td&gt;
&lt;td&gt;3.68 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;nvidia GLiNER-PII [8]&lt;/td&gt;
&lt;td&gt;570M&lt;/td&gt;
&lt;td&gt;66.4%&lt;/td&gt;
&lt;td&gt;75.1%&lt;/td&gt;
&lt;td&gt;429 ms&lt;/td&gt;
&lt;td&gt;9.45 s&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Emails and phone numbers are close to solved for every model except nvidia GLiNER-PII, which marks the names inside an email address such as &lt;code&gt;megan.donovan@lilly.com&lt;/code&gt; as two names and scores 34% on emails. Names sit at 86–88% for both PII Extractor and PII-Tracer. Addresses are where PII Extractor pulls furthest ahead: 63% for the 68M model, against 51% for PII-Tracer and 8% for GLiNER2-PII. Account numbers and links remain hard for every model, and appear only 167 and 21 times in the benchmark.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcms2wsiecu81y1vdcdiu.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcms2wsiecu81y1vdcdiu.png" alt="Privacy-Bench F1 per PII type" width="800" height="427"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;n/a: PII-Tracer does not support usernames, so it is not scored on them. Dates and secrets are not shown because Privacy-Bench does not annotate them.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;On PII-TRACE, a benchmark of multi-turn conversations released alongside PII-Tracer, PII-Tracer leads with 92.6% against 84.6% for PII Extractor-32M, mostly because that benchmark also labels meeting dates and reference codes, which PII Extractor deliberately leaves unmarked.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fewer false alarms, cleaner redaction
&lt;/h2&gt;

&lt;p&gt;An F1 score combines two different failures. A missed value leaks personal data. A false alarm hides ordinary text and makes a document harder to use, which is why over-eager detectors tend to get switched off.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsecktih2nyl1nb8bidze.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsecktih2nyl1nb8bidze.png" alt="Missed values and false alarms on Privacy-Bench" width="800" height="420"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Out of 8,490 PII values in Privacy-Bench, PII Extractor-68M and PII-Tracer miss a similar number (613 and 567). The difference is in what they flag that isn't PII: 342 false alarms for PII Extractor-68M against 546 for PII-Tracer, 37% fewer. GLiNER2-PII makes the fewest false alarms but misses about one value in five. nvidia GLiNER-PII misses the fewest values (538) but raises 3,194 false alarms, more than nine times as many as PII Extractor-68M.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fast enough for every request, even without a GPU
&lt;/h2&gt;

&lt;p&gt;We timed every model on the same 50 text samples at each of three lengths, 1,000, 2,000 and 3,000 tokens, and report the median time per sample.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxqv2xcpjf0efrkiu1w47.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxqv2xcpjf0efrkiu1w47.png" alt="Median time per sample on a T4 GPU" width="800" height="460"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;On a T4 GPU, all three PII Extractor models stay under 70 milliseconds per sample, even at 3,000 tokens. PII-Tracer takes 271 milliseconds at 1,000 tokens and almost 2 seconds at 3,000. nvidia GLiNER-PII is the slowest at 1,000 tokens, at 429 milliseconds, and takes 1.6 seconds at 3,000.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzh1x40fmsdz6mt8uwlei.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzh1x40fmsdz6mt8uwlei.png" alt="Median time per sample on four CPU threads" width="800" height="460"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Without a GPU, PII Extractor-17M takes 0.17 seconds at 1,000 tokens and 0.48 seconds at 3,000, against 9.15 and 37.37 seconds for PII-Tracer. That makes it practical on ordinary application servers.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which size to choose
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;PII Extractor-68M&lt;/strong&gt; for the highest accuracy, on a GPU.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;PII Extractor-32M&lt;/strong&gt; for the best balance of accuracy and speed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;PII Extractor-17M&lt;/strong&gt; for CPU-only servers and the lowest cost.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How we evaluated
&lt;/h2&gt;

&lt;p&gt;We ran every model ourselves, on the same texts, with the same scoring. &lt;strong&gt;Privacy-Bench&lt;/strong&gt; [1] contains 656 pages of Word and PDF business documents with 8,490 PII values annotated by people. &lt;strong&gt;PII-TRACE&lt;/strong&gt; [2] contains 500 multi-turn conversations with 2,442 annotated values.&lt;/p&gt;

&lt;p&gt;A prediction counts as correct only when its start, end and type all match the annotation. Each benchmark's types were mapped to ours as below, and every model was scored on the types that both the benchmark and the model support.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;PII Extractor&lt;/th&gt;
&lt;th&gt;Privacy-Bench&lt;/th&gt;
&lt;th&gt;PII-TRACE&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;PERSON&lt;/td&gt;
&lt;td&gt;NAME_GIVEN, NAME_FAMILY&lt;/td&gt;
&lt;td&gt;private_person&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EMAIL&lt;/td&gt;
&lt;td&gt;EMAIL_ADDRESS&lt;/td&gt;
&lt;td&gt;private_email&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PHONE&lt;/td&gt;
&lt;td&gt;PHONE_NUMBER&lt;/td&gt;
&lt;td&gt;private_phone&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ADDRESS&lt;/td&gt;
&lt;td&gt;LOCATION_ADDRESS&lt;/td&gt;
&lt;td&gt;private_address&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;URL&lt;/td&gt;
&lt;td&gt;URL&lt;/td&gt;
&lt;td&gt;private_url&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ACCOUNT_NUMBER&lt;/td&gt;
&lt;td&gt;ACCOUNT_NUMBER&lt;/td&gt;
&lt;td&gt;account_number&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;USERNAME&lt;/td&gt;
&lt;td&gt;USERNAME&lt;/td&gt;
&lt;td&gt;Not annotated&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DATE&lt;/td&gt;
&lt;td&gt;Not annotated&lt;/td&gt;
&lt;td&gt;private_date&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SECRET&lt;/td&gt;
&lt;td&gt;Not annotated&lt;/td&gt;
&lt;td&gt;secret&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;GOV_ID, IP_ADDRESS and OTHER_ID are not annotated in either benchmark, so this evaluation does not cover them.&lt;/p&gt;

&lt;p&gt;Latency is the median of 50 text samples per length, processed one at a time on a Tesla T4 GPU and on four CPU threads. PII-TRACE scores use its public subset, so they are not comparable with the official test results in the PII-Tracer paper [2].&lt;/p&gt;

&lt;h2&gt;
  
  
  Limitations
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;English only.&lt;/strong&gt; The models were trained and tested on English text.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Our definitions of PII.&lt;/strong&gt; Sensitive attributes such as health, religion or ethnicity are not detected in this version.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Rare types.&lt;/strong&gt; Usernames, account numbers and links are found less reliably than names, emails and phones.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What's next
&lt;/h2&gt;

&lt;p&gt;We're bringing &lt;strong&gt;dynamic labels at run time&lt;/strong&gt; to our super-efficient, lightweight models: describe the PII types you need when you call the model, in the style of GLiNER [5], and get them back with no retraining, at a size that still runs on every request.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try PII Extractor
&lt;/h2&gt;

&lt;p&gt;All three models are on Hugging Face under the Apache-2.0 licence: &lt;a href="https://huggingface.co/CobuildX-AI/cbx-pii-extractor-68M" rel="noopener noreferrer"&gt;pii-extractor-68M&lt;/a&gt;, &lt;a href="https://huggingface.co/CobuildX-AI/cbx-pii-extractor-32M" rel="noopener noreferrer"&gt;pii-extractor-32M&lt;/a&gt; and &lt;a href="https://huggingface.co/CobuildX-AI/cbx-pii-extractor-17M" rel="noopener noreferrer"&gt;pii-extractor-17M&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Need PII detection tuned to your own definitions, documents or languages? Get in touch with our team at &lt;strong&gt;&lt;a href="https://cobuildx.ai/contact" rel="noopener noreferrer"&gt;cobuildx.ai/contact&lt;/a&gt;&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Benchmarks
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;TonicAI. &lt;em&gt;Privacy-Bench&lt;/em&gt; (human-annotated documents). &lt;a href="https://huggingface.co/datasets/TonicAI/Privacy-Bench" rel="noopener noreferrer"&gt;https://huggingface.co/datasets/TonicAI/Privacy-Bench&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;K. Zhang et al. &lt;em&gt;PII-TRACE: A Benchmark for Context-Aware PII Detection in Multi-Turn LLM Conversations.&lt;/em&gt; arXiv:2609.22200, 2026. &lt;a href="https://huggingface.co/datasets/perplexity-ai/PII-TRACE" rel="noopener noreferrer"&gt;https://huggingface.co/datasets/perplexity-ai/PII-TRACE&lt;/a&gt;
&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  Models and methods
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;Perplexity AI. &lt;em&gt;PII-Tracer.&lt;/em&gt; &lt;a href="https://huggingface.co/perplexity-ai/PII-Tracer" rel="noopener noreferrer"&gt;https://huggingface.co/perplexity-ai/PII-Tracer&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Fastino. &lt;em&gt;GLiNER2-PII.&lt;/em&gt; &lt;a href="https://huggingface.co/fastino/gliner2-privacy-filter-PII-multi" rel="noopener noreferrer"&gt;https://huggingface.co/fastino/gliner2-privacy-filter-PII-multi&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;U. Zaratiana et al. &lt;em&gt;GLiNER: Generalist Model for Named Entity Recognition using Bidirectional Transformer.&lt;/em&gt; NAACL 2024. arXiv:2311.08526.&lt;/li&gt;
&lt;li&gt;O. Weller et al. &lt;em&gt;Seq vs Seq: An Open Suite of Paired Encoders and Decoders&lt;/em&gt; (Ettin). arXiv:2507.11412, 2025.&lt;/li&gt;
&lt;li&gt;B. Warner et al. &lt;em&gt;Smarter, Better, Faster, Longer: A Modern Bidirectional Encoder for Fast, Memory Efficient, and Long Context Finetuning and Inference&lt;/em&gt; (ModernBERT). arXiv:2412.13663, 2024.&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  Other baselines
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;NVIDIA. &lt;em&gt;gliner-PII.&lt;/em&gt; &lt;a href="https://huggingface.co/nvidia/gliner-PII" rel="noopener noreferrer"&gt;https://huggingface.co/nvidia/gliner-PII&lt;/a&gt;
&lt;/li&gt;
&lt;/ol&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://cobuildx.ai/blog/pii-extractor" rel="noopener noreferrer"&gt;cobuildx.ai&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>machinelearning</category>
      <category>privacy</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Moving Storage from GCP to AWS: Cloud Storage, Disks and File Shares</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Wed, 28 Oct 2026 10:29:34 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/moving-storage-from-gcp-to-aws-cloud-storage-disks-and-file-shares-17ko</link>
      <guid>https://dev.to/cobuildx-ai/moving-storage-from-gcp-to-aws-cloud-storage-disks-and-file-shares-17ko</guid>
      <description>&lt;p&gt;&lt;em&gt;A plain-English guide to moving storage from Google Cloud to AWS: Cloud Storage, Persistent Disk, Filestore, backups and transfer tools. What replaces what, how storage classes and access change, how to copy the data safely, what changes on the bill, and a step-by-step plan.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Every app keeps data somewhere. Photos that users upload. Disks that servers run on. Folders that many machines share. Backups. Records that must be kept for years. All of this is "storage". When you move from Google Cloud (GCP) to AWS, storage is often the biggest thing to carry across.&lt;/p&gt;

&lt;p&gt;On GCP, storage means three main things:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Cloud Storage&lt;/strong&gt; keeps files in buckets. A bucket is like a big folder in the cloud. Each file in it is called an object.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Persistent Disk and Hyperdisk&lt;/strong&gt; are the hard drives attached to virtual machines.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Filestore&lt;/strong&gt; is a shared folder that many machines can use at the same time.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Around these sit backups and tools for copying data.&lt;/p&gt;

&lt;p&gt;Storage looks easy to move. A bucket is a bucket. But the details are different. The cheap "cold" storage works in a different way. Access rules are written in a different way. And copying many terabytes takes time and money. On top of that, every file must arrive whole. Not one file can be lost or changed.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"S3 is effectively a living, breathing organism."&lt;/p&gt;

&lt;p&gt;— &lt;strong&gt;Andy Warfield&lt;/strong&gt;, VP and Distinguished Engineer at Amazon S3, in &lt;a href="https://www.allthingsdistributed.com/2023/07/building-and-operating-a-pretty-big-storage-system.html" rel="noopener noreferrer"&gt;&lt;em&gt;Building and operating a pretty big storage system called S3&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;That is a good way to think about the move. You are not just dropping files into a box. You are moving into a service with its own habits. This guide covers:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which AWS service replaces each GCP storage service&lt;/li&gt;
&lt;li&gt;What works differently on AWS&lt;/li&gt;
&lt;li&gt;How to copy the data safely&lt;/li&gt;
&lt;li&gt;What changes on the bill&lt;/li&gt;
&lt;li&gt;A simple step-by-step plan&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The Quick Map
&lt;/h2&gt;

&lt;p&gt;Here is each GCP storage service and its closest match on AWS. The rest of the post explains each row.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjn5k9l1fp6dduupjswgx.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjn5k9l1fp6dduupjswgx.png" alt="Storage service map from Google Cloud to AWS: Cloud Storage to Amazon S3, Persistent Disk and Hyperdisk to Amazon EBS, Local SSD to EC2 instance store, Filestore to Amazon EFS or FSx, Backup and DR to AWS Backup, and Storage Transfer Service to AWS DataSync" width="800" height="460"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;GCP&lt;/th&gt;
&lt;th&gt;Closest AWS match&lt;/th&gt;
&lt;th&gt;Watch out for&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Cloud Storage&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html" rel="noopener noreferrer"&gt;Amazon S3&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Cold storage works differently&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Autoclass&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/intelligent-tiering.html" rel="noopener noreferrer"&gt;S3 Intelligent-Tiering&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Very small files are not moved to cheaper tiers&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Persistent Disk / Hyperdisk&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/ebs/latest/userguide/what-is-ebs.html" rel="noopener noreferrer"&gt;Amazon EBS&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;You set disk speed yourself&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Regional Persistent Disk&lt;/td&gt;
&lt;td&gt;No direct match&lt;/td&gt;
&lt;td&gt;An EBS disk lives in one data center&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Local SSD&lt;/td&gt;
&lt;td&gt;EC2 instance store&lt;/td&gt;
&lt;td&gt;Data is lost when the machine stops&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Filestore&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html" rel="noopener noreferrer"&gt;Amazon EFS&lt;/a&gt;, or Amazon FSx&lt;/td&gt;
&lt;td&gt;Pick by how the folder is shared&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Google Cloud NetApp Volumes&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/what-is-fsx-ontap.html" rel="noopener noreferrer"&gt;Amazon FSx for NetApp ONTAP&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Same NetApp tools on both sides&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Backup and DR Service&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html" rel="noopener noreferrer"&gt;AWS Backup&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Backup plans are set up again, not copied&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Storage Transfer Service&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/datasync/latest/userguide/tutorial_transfer-google-cloud-storage.html" rel="noopener noreferrer"&gt;AWS DataSync&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;DataSync can read Cloud Storage directly&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Transfer Appliance&lt;/td&gt;
&lt;td&gt;Copy over the network with DataSync&lt;/td&gt;
&lt;td&gt;Snowball is closed to new customers&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;What about Snowball?&lt;/strong&gt; Snowball was AWS's way to ship large amounts of data on a physical device. But AWS &lt;a href="https://docs.aws.amazon.com/snowball/latest/developer-guide/snowball-edge-availability-change.html" rel="noopener noreferrer"&gt;stopped offering Snowball Edge to new customers on November 7, 2025&lt;/a&gt;. For a move from one cloud to another, copying over the network is the normal path anyway.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Cloud Storage to Amazon S3
&lt;/h2&gt;

&lt;p&gt;Cloud Storage and &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html" rel="noopener noreferrer"&gt;Amazon S3&lt;/a&gt; work the same basic way. You make buckets. You put files in them. Each file has a name, its data and a few labels (called metadata). Almost everything you do in one, you can do in the other.&lt;/p&gt;

&lt;p&gt;Google even offers an &lt;a href="https://cloud.google.com/storage/docs/interoperability" rel="noopener noreferrer"&gt;S3-style way to talk to Cloud Storage&lt;/a&gt;. That is why many AWS tools can read your GCP buckets directly.&lt;/p&gt;

&lt;h3&gt;
  
  
  Storage classes
&lt;/h3&gt;

&lt;p&gt;A storage class is a price plan for your files. Files you read often go in a normal class. Files you rarely read go in a cheaper "cold" class. You pay less to keep them, but more to read them.&lt;/p&gt;

&lt;p&gt;Both clouds have these classes, and the names roughly line up. But there is one big difference. On GCP, every class gives your file back in milliseconds, even Archive. On AWS, the two coldest classes do not. You must first &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/restoring-objects.html" rel="noopener noreferrer"&gt;ask AWS to restore the file&lt;/a&gt;, and that can take minutes or hours.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Cloud Storage class&lt;/th&gt;
&lt;th&gt;S3 class to use&lt;/th&gt;
&lt;th&gt;Shortest time you pay for&lt;/th&gt;
&lt;th&gt;How fast you can read it&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Standard&lt;/td&gt;
&lt;td&gt;S3 Standard&lt;/td&gt;
&lt;td&gt;No minimum&lt;/td&gt;
&lt;td&gt;Right away&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Nearline&lt;/td&gt;
&lt;td&gt;S3 Standard-IA&lt;/td&gt;
&lt;td&gt;30 days&lt;/td&gt;
&lt;td&gt;Right away&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Coldline&lt;/td&gt;
&lt;td&gt;S3 Glacier Instant Retrieval&lt;/td&gt;
&lt;td&gt;90 days&lt;/td&gt;
&lt;td&gt;Right away&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Archive&lt;/td&gt;
&lt;td&gt;S3 Glacier Instant Retrieval&lt;/td&gt;
&lt;td&gt;90 days&lt;/td&gt;
&lt;td&gt;Right away&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Archive (if nobody needs it fast)&lt;/td&gt;
&lt;td&gt;S3 Glacier Deep Archive&lt;/td&gt;
&lt;td&gt;180 days&lt;/td&gt;
&lt;td&gt;Hours, after a restore&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Autoclass&lt;/td&gt;
&lt;td&gt;S3 Intelligent-Tiering&lt;/td&gt;
&lt;td&gt;No minimum&lt;/td&gt;
&lt;td&gt;Right away&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These numbers come from the &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html" rel="noopener noreferrer"&gt;S3 storage class guide&lt;/a&gt;. One more thing to know: in S3 Standard-IA and Glacier Instant Retrieval, every file is billed as if it were at least 128 KB. If you have millions of tiny files, a cold class can cost more, not less.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Rule of thumb:&lt;/strong&gt; if an app still reads old files, move Archive to Glacier Instant Retrieval. Use Deep Archive only for files nobody needs in a hurry, like old backups and legal copies.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h3&gt;
  
  
  Bucket settings
&lt;/h3&gt;

&lt;p&gt;Most bucket settings have a direct match on AWS. They just have new names:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Cloud Storage&lt;/th&gt;
&lt;th&gt;Amazon S3&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Lifecycle rules (move or delete old files)&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html" rel="noopener noreferrer"&gt;S3 Lifecycle&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Object versioning (keep old copies)&lt;/td&gt;
&lt;td&gt;S3 Versioning&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dual-region and multi-region buckets&lt;/td&gt;
&lt;td&gt;A bucket in one region, plus &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html" rel="noopener noreferrer"&gt;S3 Replication&lt;/a&gt; if you need a second copy&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Retention lock (files can't be deleted)&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock.html" rel="noopener noreferrer"&gt;S3 Object Lock&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Your own encryption keys (Cloud KMS)&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html" rel="noopener noreferrer"&gt;Encryption with AWS KMS keys&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pub/Sub notifications when a file changes&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html" rel="noopener noreferrer"&gt;S3 Event Notifications&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Signed URLs (short-lived download links)&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html" rel="noopener noreferrer"&gt;Pre-signed URLs&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;gcloud storage&lt;/code&gt; command line&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;aws s3&lt;/code&gt; command line&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  Who can read and write
&lt;/h3&gt;

&lt;p&gt;On GCP, most teams give people and apps a role on the bucket, like "Storage Object Viewer". On AWS, access comes from two places. IAM policies say what a user or app may do. A bucket policy says who may use the bucket.&lt;/p&gt;

&lt;p&gt;Leave &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html" rel="noopener noreferrer"&gt;Block Public Access&lt;/a&gt; turned on. It stops a bucket from being opened to the whole internet by mistake. New buckets have it on by default. If files really must be public, like images on a website, serve them through CloudFront instead of opening the bucket.&lt;/p&gt;

&lt;h2&gt;
  
  
  Disks: Persistent Disk to EBS
&lt;/h2&gt;

&lt;p&gt;Disks for virtual machines move to &lt;a href="https://docs.aws.amazon.com/ebs/latest/userguide/what-is-ebs.html" rel="noopener noreferrer"&gt;Amazon EBS&lt;/a&gt;. The main change is how speed works.&lt;/p&gt;

&lt;p&gt;Disk speed is measured in IOPS: how many reads and writes the disk can do each second. On GCP, a bigger disk is often a faster disk. On AWS, the usual disk type (gp3) &lt;a href="https://docs.aws.amazon.com/ebs/latest/userguide/general-purpose.html" rel="noopener noreferrer"&gt;lets you choose the speed on its own&lt;/a&gt;. Every gp3 disk starts at 3,000 IOPS, and you pay extra to go higher.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;GCP disk&lt;/th&gt;
&lt;th&gt;EBS disk&lt;/th&gt;
&lt;th&gt;Good for&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;pd-standard&lt;/td&gt;
&lt;td&gt;st1 (hard drive), or gp3&lt;/td&gt;
&lt;td&gt;Big files read from start to end&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;pd-balanced&lt;/td&gt;
&lt;td&gt;gp3&lt;/td&gt;
&lt;td&gt;Most apps&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;pd-ssd&lt;/td&gt;
&lt;td&gt;gp3 with more IOPS&lt;/td&gt;
&lt;td&gt;Busy databases&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;pd-extreme, Hyperdisk Extreme&lt;/td&gt;
&lt;td&gt;io2&lt;/td&gt;
&lt;td&gt;Very busy databases&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two GCP disks have no exact match:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Regional Persistent Disk&lt;/strong&gt; keeps a copy of the disk in two zones (two separate data centers). An EBS disk lives in one zone. On AWS, you get the same safety another way: a database copy in a second zone, or regular snapshots.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Local SSD&lt;/strong&gt; becomes EC2 instance store. The warning is the same on both clouds: the data is gone when the machine stops. Use it only for data you can rebuild.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Disks usually move together with their machines. &lt;a href="https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html" rel="noopener noreferrer"&gt;AWS Application Migration Service&lt;/a&gt; copies a running machine and its disks to AWS, and keeps them in sync until you switch.&lt;/p&gt;

&lt;h2&gt;
  
  
  Shared Folders: Filestore to EFS or FSx
&lt;/h2&gt;

&lt;p&gt;Filestore gives many machines one shared folder. Machines reach it over the network using NFS, a common way to share folders on Linux. AWS has a few choices. Pick by what your apps need:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html" rel="noopener noreferrer"&gt;Amazon EFS&lt;/a&gt;&lt;/strong&gt; is the simple match for most Filestore use. It uses NFS. It grows and shrinks on its own, so you never pick a size. It keeps your data in several zones. You pay for what you store.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/what-is-fsx-ontap.html" rel="noopener noreferrer"&gt;Amazon FSx for NetApp ONTAP&lt;/a&gt;&lt;/strong&gt; fits apps that need both Linux and Windows sharing, or NetApp features like instant copies. It is also the direct match for Google Cloud NetApp Volumes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html" rel="noopener noreferrer"&gt;Amazon FSx for Lustre&lt;/a&gt;&lt;/strong&gt; is for very heavy work, like training AI models. It can read files straight from S3.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html" rel="noopener noreferrer"&gt;Amazon FSx for Windows File Server&lt;/a&gt;&lt;/strong&gt; is for Windows apps.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;One tip: EFS is fast when many machines read at once, but each small file takes a little time to open. Apps that open thousands of tiny files one by one can feel slower. Test with your real app before you decide.&lt;/p&gt;

&lt;h2&gt;
  
  
  Moving the Data
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm6mf52cl5run72jke8d5.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm6mf52cl5run72jke8d5.png" alt="How the data moves: Cloud Storage buckets are copied to Amazon S3 by AWS DataSync without an agent; Filestore shares are copied to EFS or FSx by a DataSync agent; disks move with their virtual machines through AWS Application Migration Service; a final sync runs before the switch" width="800" height="380"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;For buckets, the best tool is &lt;a href="https://docs.aws.amazon.com/datasync/latest/userguide/tutorial_transfer-google-cloud-storage.html" rel="noopener noreferrer"&gt;AWS DataSync&lt;/a&gt;. It reads Cloud Storage directly. You give it a key from GCP, and it copies files into S3. For bucket to bucket copies, you don't need to install anything on GCP.&lt;/p&gt;

&lt;p&gt;DataSync also checks every file after it copies it. On later runs, it only copies what changed. And it writes a report, so you can prove what was moved.&lt;/p&gt;

&lt;p&gt;For Filestore, DataSync needs a small helper machine (an "agent") running on GCP, close to the data. For disks, move the whole machine with Application Migration Service.&lt;/p&gt;

&lt;p&gt;A safe copy follows the same steps every time:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;First full copy&lt;/strong&gt; while the old system keeps running. For big buckets, this can take days.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Catch-up copies&lt;/strong&gt; that only move what changed. Each one is shorter than the last.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Final copy.&lt;/strong&gt; Stop writes for a short time, run one last copy, then point your apps at AWS.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Check everything.&lt;/strong&gt; Compare the number of files, their sizes and their checksums. A checksum is like a fingerprint of a file. If the fingerprints match, the file arrived unchanged.&lt;/li&gt;
&lt;/ol&gt;

&lt;blockquote&gt;
&lt;p&gt;"These are simple mechanisms that protect you from a large class of risks."&lt;/p&gt;

&lt;p&gt;— &lt;strong&gt;Andy Warfield&lt;/strong&gt;, VP and Distinguished Engineer at Amazon S3, in &lt;a href="https://www.allthingsdistributed.com/2023/07/building-and-operating-a-pretty-big-storage-system.html" rel="noopener noreferrer"&gt;&lt;em&gt;Building and operating a pretty big storage system called S3&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Checks are simple too, and they are what make a move safe. Don't delete anything on GCP until they pass.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Ask about Google's exit offer.&lt;/strong&gt; Data leaving GCP normally costs money for every GB. Google offers &lt;a href="https://cloud.google.com/exit-cloud" rel="noopener noreferrer"&gt;free data transfer for customers who leave Google Cloud&lt;/a&gt;. You must apply first, and there are rules. Talk to your Google account team before the big copy starts.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  A Simple Way to Decide
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftdohwjua75t2y79qb90j.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftdohwjua75t2y79qb90j.png" alt="Storage decision flow: if it is files in buckets, use Amazon S3 and pick the class by how often data is read; if it is a disk for one machine, use EBS gp3 or io2; if many machines share a folder, use Amazon EFS, or FSx for NetApp ONTAP, Lustre or Windows; if it is backups, use AWS Backup" width="800" height="434"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Is it files in a bucket?&lt;/strong&gt; Use S3. Pick the class by how often the files are read. If you don't know, use Intelligent-Tiering.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Is it a disk for one machine?&lt;/strong&gt; Use EBS gp3. Use io2 only for the busiest databases.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Do many machines share one folder?&lt;/strong&gt; Use EFS. Use FSx if you need Windows sharing, NetApp features or very heavy work.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Is it a backup?&lt;/strong&gt; Use &lt;a href="https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html" rel="noopener noreferrer"&gt;AWS Backup&lt;/a&gt;. Keep a copy in a separate AWS account, so one mistake can't delete both.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  What Changes on the Bill
&lt;/h2&gt;

&lt;p&gt;Storage prices look simple: a price for each GB, each month. The surprises come from everything around that:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Cost&lt;/th&gt;
&lt;th&gt;GCP&lt;/th&gt;
&lt;th&gt;AWS&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Keeping files&lt;/td&gt;
&lt;td&gt;Per GB per month, by class&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://aws.amazon.com/s3/pricing/" rel="noopener noreferrer"&gt;S3&lt;/a&gt;: per GB per month, by class&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Reading and writing&lt;/td&gt;
&lt;td&gt;A fee per 1,000 actions&lt;/td&gt;
&lt;td&gt;A fee per 1,000 requests; higher for cold classes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Reading cold files&lt;/td&gt;
&lt;td&gt;A fee per GB&lt;/td&gt;
&lt;td&gt;A fee per GB, and a wait for Glacier&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Deleting too early&lt;/td&gt;
&lt;td&gt;You pay the minimum time&lt;/td&gt;
&lt;td&gt;You pay the minimum time, and for at least 128 KB per file&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Disks&lt;/td&gt;
&lt;td&gt;Per GB; speed comes with size&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://aws.amazon.com/ebs/pricing/" rel="noopener noreferrer"&gt;EBS&lt;/a&gt;: per GB, plus extra speed if you want it&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Shared folders&lt;/td&gt;
&lt;td&gt;Filestore: for the size you set aside&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://aws.amazon.com/efs/pricing/" rel="noopener noreferrer"&gt;EFS&lt;/a&gt;: for what you actually store&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Data leaving the cloud&lt;/td&gt;
&lt;td&gt;Per GB&lt;/td&gt;
&lt;td&gt;Per GB&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Three things catch teams out:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Lots of tiny files.&lt;/strong&gt; Request fees and the 128 KB minimum add up fast. Bundle small files together, or keep them in S3 Standard.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Copying lifecycle rules as they are.&lt;/strong&gt; A rule that moves files to a cold class is cheap on GCP. On AWS, moving millions of small files into Glacier costs a fee for each one.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;NAT gateways.&lt;/strong&gt; Machines in a private network often reach S3 through a NAT gateway, which charges for every GB. Add a free &lt;a href="https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-s3.html" rel="noopener noreferrer"&gt;S3 gateway endpoint&lt;/a&gt; instead.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Turn on &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens.html" rel="noopener noreferrer"&gt;S3 Storage Lens&lt;/a&gt; early. It shows which buckets are growing, which files nobody reads, and where a lifecycle rule would save money.&lt;/p&gt;

&lt;h2&gt;
  
  
  What It Looks Like in Code
&lt;/h2&gt;

&lt;p&gt;Uploading a file and making a one-hour download link, on GCP and on AWS:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# GCP: Cloud Storage (Python)
from datetime import timedelta
from google.cloud import storage

bucket = storage.Client().bucket("shop-invoices")
blob = bucket.blob("2026/10/inv-1042.pdf")
blob.upload_from_filename("inv-1042.pdf")
url = blob.generate_signed_url(expiration=timedelta(hours=1))

# AWS: Amazon S3 (Python)
import boto3

s3 = boto3.client("s3")
s3.upload_file("inv-1042.pdf", "shop-invoices", "2026/10/inv-1042.pdf")
url = s3.generate_presigned_url(
    "get_object",
    Params={"Bucket": "shop-invoices", "Key": "2026/10/inv-1042.pdf"},
    ExpiresIn=3600,
)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And a bucket that keeps old versions and moves files to a cold class after 90 days, in Terraform:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# GCP: a Cloud Storage bucket
resource "google_storage_bucket" "invoices" {
  name                        = "shop-invoices"
  location                    = "US-CENTRAL1"
  uniform_bucket_level_access = true
  versioning { enabled = true }
  lifecycle_rule {
    condition { age = 90 }
    action {
      type          = "SetStorageClass"
      storage_class = "COLDLINE"
    }
  }
}

# AWS: the same bucket in S3 (each setting is its own resource)
resource "aws_s3_bucket" "invoices" {
  bucket = "shop-invoices"   # names are global; it may be taken
}

resource "aws_s3_bucket_versioning" "invoices" {
  bucket = aws_s3_bucket.invoices.id
  versioning_configuration { status = "Enabled" }
}

resource "aws_s3_bucket_lifecycle_configuration" "invoices" {
  bucket = aws_s3_bucket.invoices.id
  rule {
    id     = "cold-after-90-days"
    status = "Enabled"
    filter {}
    transition {
      days          = 90
      storage_class = "GLACIER_IR"   # was COLDLINE
    }
  }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;These snippets show the shape, not every setting. Check the current docs before you copy them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Things That Bite Later
&lt;/h2&gt;

&lt;blockquote&gt;
&lt;p&gt;"Failures are a given and everything will eventually fail over time."&lt;/p&gt;

&lt;p&gt;— &lt;strong&gt;Werner Vogels&lt;/strong&gt;, CTO of Amazon, in &lt;a href="https://www.allthingsdistributed.com/2016/03/10-lessons-from-10-years-of-aws.html" rel="noopener noreferrer"&gt;&lt;em&gt;10 Lessons from 10 Years of AWS&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;These are the small things that tend to break after the move:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Old file paths.&lt;/strong&gt; Paths like &lt;code&gt;gs://bucket/file&lt;/code&gt; and links to &lt;code&gt;storage.googleapis.com&lt;/code&gt; hide in code, settings, scripts and database rows. Search for all of them, including links you have already sent to customers.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Bucket names.&lt;/strong&gt; Bucket names must be unique across all of AWS. The name you used on GCP may already be taken. Choose names early.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;File labels.&lt;/strong&gt; Labels like &lt;code&gt;Content-Type&lt;/code&gt; tell a browser what a file is. If they are not copied, a browser may download a picture instead of showing it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cold files that need a restore.&lt;/strong&gt; Code that reads from Archive on GCP will fail on Glacier Deep Archive until the file is restored.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sudden heavy traffic.&lt;/strong&gt; S3 handles &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html" rel="noopener noreferrer"&gt;thousands of requests per second&lt;/a&gt; and grows over time. But a brand-new bucket hit hard on day one can slow down at first. Ramp up traffic step by step.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;File change alerts.&lt;/strong&gt; If apps react when a file is added, those alerts move to &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html" rel="noopener noreferrer"&gt;S3 Event Notifications&lt;/a&gt;. The alert looks different, so the code that reads it needs a small change.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Doing the Move, Step by Step
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;List everything.&lt;/strong&gt; Every bucket, disk, shared folder and backup, with its size, number of files, class, cost, owner and the apps that use it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pick the AWS service&lt;/strong&gt; and storage class for each one, using the questions above. Write down why.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Set up the base:&lt;/strong&gt; AWS accounts, networks, S3 gateway endpoints, encryption keys in &lt;a href="https://docs.aws.amazon.com/kms/latest/developerguide/overview.html" rel="noopener noreferrer"&gt;AWS KMS&lt;/a&gt;, access rules and backup plans.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Apply for Google's exit offer&lt;/strong&gt; before the big copy starts.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Start with one bucket.&lt;/strong&gt; Copy it with DataSync, check it, and point one app at it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Move the rest in waves.&lt;/strong&gt; For each wave: full copy, catch-up copies, a short freeze, a final copy, then checks.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Clean up.&lt;/strong&gt; Keep the GCP data read-only for a while, then delete it. Remove old keys and accounts. Review the AWS bill after the first full month.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Storage is the heaviest part of a cloud move, but it is also the most predictable. The services match closely. The work is in the details: cold classes, access rules, tiny files and a careful final copy. Get those right, and your data arrives whole.&lt;/p&gt;

&lt;h2&gt;
  
  
  Common Questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  How do I transfer data from GCS to S3?
&lt;/h3&gt;

&lt;p&gt;Use AWS DataSync. It reads Google Cloud Storage directly with a GCP key, so bucket-to-bucket copies need nothing installed on GCP. It checks every file, copies only what changed on later runs, and writes a report. Run a full copy, catch-up copies, then a short freeze and a final copy.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is Google Cloud Storage S3 compatible?
&lt;/h3&gt;

&lt;p&gt;Partly. Cloud Storage has an S3-style XML API, which is why DataSync, rclone and many S3 tools can read GCS buckets directly. Your apps still need small changes once they move to real S3, such as signed URLs becoming pre-signed URLs.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can I use rclone instead of DataSync for GCS to S3?
&lt;/h3&gt;

&lt;p&gt;For small buckets, yes. For large moves, DataSync is safer: it checks every file, retries, runs incremental syncs and gives you a report you can show auditors.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the GCP Filestore equivalent in AWS?
&lt;/h3&gt;

&lt;p&gt;Amazon EFS for most NFS shares. Use FSx for NetApp ONTAP for mixed Linux and Windows sharing or NetApp features, FSx for Lustre for heavy AI and HPC work, and FSx for Windows File Server for Windows apps.&lt;/p&gt;

&lt;h3&gt;
  
  
  Persistent Disk vs EBS: what is different?
&lt;/h3&gt;

&lt;p&gt;On GCP a bigger disk is a faster disk. On EBS gp3 you set speed on its own: every disk starts at 3,000 IOPS and you pay for more. pd-balanced maps to gp3, pd-ssd to gp3 with more IOPS, and pd-extreme to io2. Regional Persistent Disk has no direct match.&lt;/p&gt;

&lt;h3&gt;
  
  
  Coldline vs Glacier: which S3 class replaces it?
&lt;/h3&gt;

&lt;p&gt;Coldline and Archive map to S3 Glacier Instant Retrieval if apps still read the files. Use Glacier Deep Archive only for files nobody needs fast, because it needs a restore that can take hours.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do I avoid GCP egress fees when moving to AWS?
&lt;/h3&gt;

&lt;p&gt;Apply for Google's free data transfer for customers leaving Google Cloud before the big copy starts. Talk to your Google account team, since there are rules to follow.&lt;/p&gt;

&lt;h2&gt;
  
  
  About MigrateX
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" alt="MigrateX" width="799" height="293"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;MigrateX is our platform and service for moving software, data and infrastructure from one technology to another. It combines automation with experienced engineers. The automation does the repetitive work quickly, and the engineers make the tricky decisions.&lt;/p&gt;

&lt;p&gt;Here's how we run a GCP to AWS storage move with MigrateX:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Assessment.&lt;/strong&gt; We list every bucket, disk, shared folder and backup, with its size, file count, class, cost and owner. You see where the work is before anyone agrees on a timeline.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan.&lt;/strong&gt; We work with your team to pick the AWS service and storage class for each one, set up access and encryption, and plan the copy waves.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Migration, step by step.&lt;/strong&gt; Automation does the repetitive parts: setting up DataSync copies, turning lifecycle rules and bucket settings into their AWS versions, and updating &lt;code&gt;gs://&lt;/code&gt; paths and Terraform. Our engineers handle the parts that need thought: cold data, very large buckets, shared folders and the final switch.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Proof that it works.&lt;/strong&gt; Every wave ends with checks on file counts, sizes and checksums. Apps are tested against the new storage before the switch.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Handover and clean-up.&lt;/strong&gt; We retire GCP storage one wave at a time, tune storage classes once real usage is known, and leave your team with a setup they understand and own.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;What you get along the way:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No lost data.&lt;/strong&gt; Every file is checked after it is copied. Nothing is deleted until the checks pass.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Short freezes.&lt;/strong&gt; Catch-up copies keep the final switch down to minutes or hours, not days.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A smaller bill, not a bigger one.&lt;/strong&gt; The right storage classes, lifecycle rules and endpoints are part of the move, not an afterthought.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One team from start to end.&lt;/strong&gt; The same people plan the move, copy the data and hand it over.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;Planning a move from GCP to AWS? We'd love to hear about it. Tell us a little about your setup through &lt;a href="https://cobuildx.ai/contact" rel="noopener noreferrer"&gt;Contact Us&lt;/a&gt;, and we'll start with a free chat about where the work is likely to be.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;h3&gt;
  
  
  AWS
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;AWS. &lt;em&gt;What is Amazon S3?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Understanding and managing Amazon S3 storage classes&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;S3 Intelligent-Tiering&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/intelligent-tiering.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/intelligent-tiering.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Restoring an archived object&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/restoring-objects.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/restoring-objects.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Managing the lifecycle of objects&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Replicating objects&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;S3 Object Lock&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Using server-side encryption with AWS KMS keys&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon S3 Event Notifications&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Blocking public access to your Amazon S3 storage&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Sharing objects with presigned URLs&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Optimizing Amazon S3 performance&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon S3 Storage Lens&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Gateway endpoints for Amazon S3&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-s3.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-s3.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;What is Amazon EBS?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/ebs/latest/userguide/what-is-ebs.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/ebs/latest/userguide/what-is-ebs.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;General Purpose SSD volumes&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/ebs/latest/userguide/general-purpose.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/ebs/latest/userguide/general-purpose.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;What is Amazon EFS?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;What is Amazon FSx for NetApp ONTAP?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/what-is-fsx-ontap.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/what-is-fsx-ontap.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;What is Amazon FSx for Lustre?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;What is Amazon FSx for Windows File Server?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;What is AWS Backup?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;AWS Key Management Service&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/kms/latest/developerguide/overview.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/kms/latest/developerguide/overview.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;What is AWS Application Migration Service?&lt;/em&gt; &lt;a href="https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Configuring AWS DataSync transfers with Google Cloud Storage&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/datasync/latest/userguide/tutorial_transfer-google-cloud-storage.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/datasync/latest/userguide/tutorial_transfer-google-cloud-storage.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;AWS Snowball Edge availability change&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/snowball/latest/developer-guide/snowball-edge-availability-change.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/snowball/latest/developer-guide/snowball-edge-availability-change.html&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Expert sources
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Andy Warfield. &lt;em&gt;Building and operating a pretty big storage system called S3&lt;/em&gt;. All Things Distributed, 2023. &lt;a href="https://www.allthingsdistributed.com/2023/07/building-and-operating-a-pretty-big-storage-system.html" rel="noopener noreferrer"&gt;https://www.allthingsdistributed.com/2023/07/building-and-operating-a-pretty-big-storage-system.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Werner Vogels. &lt;em&gt;10 Lessons from 10 Years of Amazon Web Services&lt;/em&gt;. All Things Distributed, 2016. &lt;a href="https://www.allthingsdistributed.com/2016/03/10-lessons-from-10-years-of-aws.html" rel="noopener noreferrer"&gt;https://www.allthingsdistributed.com/2016/03/10-lessons-from-10-years-of-aws.html&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Google Cloud
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Storage classes&lt;/em&gt;. &lt;a href="https://cloud.google.com/storage/docs/storage-classes" rel="noopener noreferrer"&gt;https://cloud.google.com/storage/docs/storage-classes&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Storage interoperability&lt;/em&gt;. &lt;a href="https://cloud.google.com/storage/docs/interoperability" rel="noopener noreferrer"&gt;https://cloud.google.com/storage/docs/interoperability&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Exit Google Cloud&lt;/em&gt;. &lt;a href="https://cloud.google.com/exit-cloud" rel="noopener noreferrer"&gt;https://cloud.google.com/exit-cloud&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;CobuildX helps teams migrate legacy applications and cloud infrastructure with &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;MigrateX&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/gcp-to-aws-storage" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>aws</category>
      <category>googlecloud</category>
      <category>cloud</category>
      <category>devops</category>
    </item>
    <item>
      <title>Moving Serverless from GCP to AWS: Cloud Run, Functions and Events</title>
      <dc:creator>Emmanuel R</dc:creator>
      <pubDate>Wed, 28 Oct 2026 10:28:58 +0000</pubDate>
      <link>https://dev.to/cobuildx-ai/moving-serverless-from-gcp-to-aws-cloud-run-functions-and-events-27nk</link>
      <guid>https://dev.to/cobuildx-ai/moving-serverless-from-gcp-to-aws-cloud-run-functions-and-events-27nk</guid>
      <description>&lt;p&gt;&lt;em&gt;A plain-English guide to moving serverless apps from Google Cloud to AWS: Cloud Run, Cloud Run functions, App Engine, Eventarc, Cloud Tasks, Scheduler and Workflows. What replaces what, what behaves differently, what changes on the bill, and a step-by-step plan.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;"Serverless" means you give the cloud your code, and it runs it for you. You don't pick servers. You don't patch them. You don't keep them running. The cloud starts your code when it is needed and stops it when it is not.&lt;/p&gt;

&lt;p&gt;On Google Cloud (GCP), serverless usually means Cloud Run, Cloud Run functions and App Engine. It also means the services that connect them: Eventarc, Pub/Sub, Cloud Tasks, Cloud Scheduler and Workflows.&lt;/p&gt;

&lt;p&gt;Teams move these apps to AWS for simple reasons. The rest of the company is on AWS. The data has already moved. Or the apps need to sit close to other AWS services.&lt;/p&gt;

&lt;p&gt;Serverless looks like the easiest thing to move. There are no servers to copy. But each cloud has different default settings, and that is where the work is. Cloud Run sends many requests to one copy of your app. Lambda sends one request at a time. Cloud Run lets a request run for an hour. Lambda stops after 15 minutes. Small differences like these can break an app that worked fine on GCP.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Serverless is, instead, a mindset: make technology decisions that further your ability to focus on what differentiates you as a business."&lt;/p&gt;

&lt;p&gt;— &lt;strong&gt;Ben Kehoe&lt;/strong&gt;, AWS Serverless Hero, in his talk &lt;a href="https://www.meetup.com/serverless-boston/events/262376552/" rel="noopener noreferrer"&gt;&lt;em&gt;Serverless as a mindset&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;That is a good test for the move too. The goal is not to copy every GCP service one to one. The goal is to end up with less to look after. This guide covers:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which AWS service replaces each GCP serverless service&lt;/li&gt;
&lt;li&gt;What works differently, and what tends to break&lt;/li&gt;
&lt;li&gt;How events, queues and schedules move&lt;/li&gt;
&lt;li&gt;What changes on the bill&lt;/li&gt;
&lt;li&gt;A simple step-by-step plan&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The Quick Map
&lt;/h2&gt;

&lt;p&gt;Here is each GCP serverless service and its closest match on AWS. The rest of the post explains each row.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1qmit1uk576an8v90kdq.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1qmit1uk576an8v90kdq.png" alt="Serverless service map from Google Cloud to AWS: Cloud Run services to ECS Express Mode on Fargate or Lambda, Cloud Run jobs to ECS tasks or AWS Batch, Cloud Run functions to AWS Lambda, App Engine to Elastic Beanstalk or ECS, Eventarc and Pub/Sub push to EventBridge and SNS plus SQS, and Workflows to Step Functions" width="800" height="460"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;GCP&lt;/th&gt;
&lt;th&gt;Closest AWS match&lt;/th&gt;
&lt;th&gt;Watch out for&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Cloud Run services&lt;/td&gt;
&lt;td&gt;Amazon ECS Express Mode, or AWS Lambda&lt;/td&gt;
&lt;td&gt;Cloud Run shares one copy of the app between many requests; Lambda does not&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cloud Run jobs&lt;/td&gt;
&lt;td&gt;ECS tasks on Fargate, or AWS Batch&lt;/td&gt;
&lt;td&gt;Task numbering and retries are set up differently&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cloud Run functions&lt;/td&gt;
&lt;td&gt;AWS Lambda&lt;/td&gt;
&lt;td&gt;15-minute limit and a new code entry point&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;App Engine standard&lt;/td&gt;
&lt;td&gt;Lambda, or Elastic Beanstalk&lt;/td&gt;
&lt;td&gt;Old built-in services must be replaced&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;App Engine flexible&lt;/td&gt;
&lt;td&gt;Elastic Beanstalk, or ECS on Fargate&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;app.yaml&lt;/code&gt; settings move to new config&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;API Gateway / Cloud Endpoints&lt;/td&gt;
&lt;td&gt;Amazon API Gateway&lt;/td&gt;
&lt;td&gt;Different login options and limits&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Eventarc&lt;/td&gt;
&lt;td&gt;Amazon EventBridge&lt;/td&gt;
&lt;td&gt;Events look different, so code that reads them changes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pub/Sub push&lt;/td&gt;
&lt;td&gt;SNS and SQS, or EventBridge&lt;/td&gt;
&lt;td&gt;Retries are set on the queue&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cloud Tasks&lt;/td&gt;
&lt;td&gt;Amazon SQS with Lambda&lt;/td&gt;
&lt;td&gt;SQS holds tasks; something must read them&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cloud Scheduler&lt;/td&gt;
&lt;td&gt;EventBridge Scheduler&lt;/td&gt;
&lt;td&gt;Each schedule names its own time zone and target&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Workflows&lt;/td&gt;
&lt;td&gt;AWS Step Functions&lt;/td&gt;
&lt;td&gt;Workflows are rewritten, not converted&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Secret Manager&lt;/td&gt;
&lt;td&gt;AWS Secrets Manager, or Parameter Store&lt;/td&gt;
&lt;td&gt;Access comes from the app's IAM role&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;What about App Runner?&lt;/strong&gt; It looks like the obvious match for Cloud Run. But AWS &lt;a href="https://docs.aws.amazon.com/apprunner/latest/dg/apprunner-availability-change.html" rel="noopener noreferrer"&gt;closed App Runner to new customers on April 30, 2026&lt;/a&gt;. For new apps, AWS points to ECS Express Mode instead.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Cloud Run: Containers or Functions
&lt;/h2&gt;

&lt;p&gt;Cloud Run runs your app in a container (a package with your code and everything it needs). It adds copies when traffic grows and removes them when traffic stops. On AWS you have two good choices:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;ECS Express Mode&lt;/strong&gt; is the closest match. You give it your container and two IAM roles. AWS &lt;a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/express-service-overview.html" rel="noopener noreferrer"&gt;sets up the rest&lt;/a&gt;: the service on Fargate, a load balancer, scaling and networking. Your container does not change. Like Cloud Run, one copy of the app can serve many requests at once.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;AWS Lambda&lt;/strong&gt; runs your code only when a request comes in. You pay per request. It is great for small APIs and for traffic that comes in bursts. But a normal Lambda copy handles &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html" rel="noopener noreferrer"&gt;one request at a time&lt;/a&gt;. Lambda can also run &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/images-create.html" rel="noopener noreferrer"&gt;container images&lt;/a&gt;, but your code must use Lambda's request format.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhy8noou533hcdrl75xws.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhy8noou533hcdrl75xws.png" alt="How requests reach your code: on Cloud Run, up to 80 or more requests share one container instance; on standard AWS Lambda, each request gets its own execution environment, so 80 requests need 80 environments" width="800" height="339"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Here are the main differences side by side. The Lambda numbers come from the &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html" rel="noopener noreferrer"&gt;Lambda quotas page&lt;/a&gt;:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Topic&lt;/th&gt;
&lt;th&gt;Cloud Run&lt;/th&gt;
&lt;th&gt;ECS Express Mode&lt;/th&gt;
&lt;th&gt;Lambda&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Requests per copy&lt;/td&gt;
&lt;td&gt;Up to 1,000 (80 is common)&lt;/td&gt;
&lt;td&gt;As many as your app can take&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Longest request&lt;/td&gt;
&lt;td&gt;60 minutes&lt;/td&gt;
&lt;td&gt;Set by the load balancer&lt;/td&gt;
&lt;td&gt;15 minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Scale to zero&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;No, at least one copy runs&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Stay warm&lt;/td&gt;
&lt;td&gt;Minimum instances&lt;/td&gt;
&lt;td&gt;Minimum number of tasks&lt;/td&gt;
&lt;td&gt;Provisioned concurrency&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Largest request body&lt;/td&gt;
&lt;td&gt;32 MiB&lt;/td&gt;
&lt;td&gt;Load balancer limits&lt;/td&gt;
&lt;td&gt;6 MB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What you deploy&lt;/td&gt;
&lt;td&gt;Container&lt;/td&gt;
&lt;td&gt;Container&lt;/td&gt;
&lt;td&gt;Zip file or container&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two things follow from this. First, database connections. On Cloud Run, 100 requests might share two copies of the app and a few connections. On Lambda, 100 requests means 100 copies, and each opens its own connections. The database can run out. Use &lt;a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy.html" rel="noopener noreferrer"&gt;RDS Proxy&lt;/a&gt; to share connections, or keep the app on ECS. Second, anything that runs for more than 15 minutes cannot go on Lambda as it is.&lt;/p&gt;

&lt;p&gt;Then there are cold starts. A cold start is the short wait while Lambda starts a new copy of your code. Many teams worry about it too much:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Cold starts that don't add to user-facing latency is generally not worth worrying about."&lt;/p&gt;

&lt;p&gt;— &lt;strong&gt;Yan Cui&lt;/strong&gt;, AWS Serverless Hero, in &lt;a href="https://www.slideshare.net/theburningmonk/running-serverless-at-scale" rel="noopener noreferrer"&gt;&lt;em&gt;Running Serverless at Scale&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If users do feel it, turn on &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html" rel="noopener noreferrer"&gt;provisioned concurrency&lt;/a&gt;, which keeps copies ready, or &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html" rel="noopener noreferrer"&gt;SnapStart&lt;/a&gt; for Java, Python and .NET.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Rule of thumb:&lt;/strong&gt; if the Cloud Run service is a full web app (a framework, a database, long requests), move the same container to ECS Express Mode. If it is a small API or webhook with spiky traffic, move it to Lambda.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;There is also a middle option. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-managed-instances.html" rel="noopener noreferrer"&gt;Lambda Managed Instances&lt;/a&gt; run Lambda on EC2 machines that AWS looks after, and one copy can handle many requests at once. It suits steady, busy traffic. Your code must be safe to run many requests in parallel.&lt;/p&gt;

&lt;h3&gt;
  
  
  Cloud Run jobs
&lt;/h3&gt;

&lt;p&gt;Cloud Run jobs run a container until the work is done, often as many tasks at once. On AWS, run the same container as an &lt;a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html" rel="noopener noreferrer"&gt;ECS task on Fargate&lt;/a&gt;. Start it from EventBridge Scheduler or Step Functions. For big jobs split into many parts, use &lt;a href="https://docs.aws.amazon.com/batch/latest/userguide/what-is-batch.html" rel="noopener noreferrer"&gt;AWS Batch&lt;/a&gt; array jobs. One small change: Cloud Run tells each task its number in &lt;code&gt;CLOUD_RUN_TASK_INDEX&lt;/code&gt;. AWS Batch uses &lt;code&gt;AWS_BATCH_JOB_ARRAY_INDEX&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Functions: Cloud Run Functions to Lambda
&lt;/h2&gt;

&lt;p&gt;Cloud Run functions (once called Cloud Functions) map most directly to &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/welcome.html" rel="noopener noreferrer"&gt;AWS Lambda&lt;/a&gt;. The idea is the same: a small piece of code that runs when a request or an event arrives. What changes is the code around it:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Topic&lt;/th&gt;
&lt;th&gt;Cloud Run functions&lt;/th&gt;
&lt;th&gt;Lambda&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Entry point&lt;/td&gt;
&lt;td&gt;Functions Framework (&lt;code&gt;@functions_framework.http&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;&lt;code&gt;handler(event, context)&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Web address&lt;/td&gt;
&lt;td&gt;Built in&lt;/td&gt;
&lt;td&gt;Function URL or API Gateway&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Started by events&lt;/td&gt;
&lt;td&gt;Eventarc or Pub/Sub&lt;/td&gt;
&lt;td&gt;SQS, SNS, EventBridge and others&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Memory and CPU&lt;/td&gt;
&lt;td&gt;Set one by one&lt;/td&gt;
&lt;td&gt;Set memory; CPU grows with it&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Longest run&lt;/td&gt;
&lt;td&gt;60 minutes for HTTP&lt;/td&gt;
&lt;td&gt;15 minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Local files&lt;/td&gt;
&lt;td&gt;Kept in memory&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;/tmp&lt;/code&gt;, up to 10 GB&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Most of the work is in the entry point and the trigger, not in the business logic. Keep the logic in its own file. Then write a thin entry point for each cloud. That way you can test both with the same code.&lt;/p&gt;

&lt;h2&gt;
  
  
  App Engine
&lt;/h2&gt;

&lt;p&gt;App Engine is GCP's oldest serverless service. How you move it depends on which kind you use:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;App Engine flexible&lt;/strong&gt; already runs containers. Move it to ECS on Fargate. Or use &lt;a href="https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/Welcome.html" rel="noopener noreferrer"&gt;Elastic Beanstalk&lt;/a&gt; if the team likes the "push code, get an app" style.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;App Engine standard&lt;/strong&gt; apps on newer runtimes are normal web apps. Put them in a container and treat them like Cloud Run.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Older App Engine apps&lt;/strong&gt; use built-in services like Memcache, Task Queues, Users and Datastore. Each needs a new home on AWS: ElastiCache, SQS, Amazon Cognito and DynamoDB. This is real code work, so find these apps early.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;App Engine also has small config files that are easy to forget. &lt;code&gt;cron.yaml&lt;/code&gt; becomes EventBridge Scheduler schedules. &lt;code&gt;dispatch.yaml&lt;/code&gt; becomes load balancer rules. &lt;code&gt;queue.yaml&lt;/code&gt; becomes SQS queues.&lt;/p&gt;

&lt;h2&gt;
  
  
  Events, Queues and Schedules
&lt;/h2&gt;

&lt;p&gt;Serverless apps talk to each other through events: "an order was placed", "a file was uploaded". This is where small differences cause the most bugs:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Eventarc to EventBridge.&lt;/strong&gt; Eventarc sends events in the CloudEvents format. &lt;a href="https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html" rel="noopener noreferrer"&gt;EventBridge&lt;/a&gt; uses its own format, with fields like &lt;code&gt;source&lt;/code&gt;, &lt;code&gt;detail-type&lt;/code&gt; and &lt;code&gt;detail&lt;/code&gt;. Every function that reads an event needs a small change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pub/Sub push to SNS and SQS.&lt;/strong&gt; Pub/Sub push calls your web address and tries again if it fails. On AWS, put an &lt;a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html" rel="noopener noreferrer"&gt;SQS queue&lt;/a&gt; in front of each reader. Lambda then &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html" rel="noopener noreferrer"&gt;reads the queue&lt;/a&gt; in batches. Messages that keep failing go to a dead-letter queue (a side queue for messages that could not be handled).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cloud Tasks to SQS.&lt;/strong&gt; Cloud Tasks calls a web address for each task, at a rate you set. SQS only holds the tasks. Something has to read them. Use Lambda with a &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-scaling.html" rel="noopener noreferrer"&gt;maximum concurrency&lt;/a&gt; setting to control the rate.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cloud Scheduler to EventBridge Scheduler.&lt;/strong&gt; &lt;a href="https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html" rel="noopener noreferrer"&gt;EventBridge Scheduler&lt;/a&gt; supports cron, time zones and one-time schedules. It can start Lambda, ECS tasks and Step Functions directly.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Workflows to Step Functions.&lt;/strong&gt; GCP Workflows are steps written in YAML. &lt;a href="https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html" rel="noopener noreferrer"&gt;Step Functions&lt;/a&gt; are steps written in JSON. The ideas are the same (steps, retries, choices, waits), but each workflow is rewritten by hand.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Make every handler safe to run twice.&lt;/strong&gt; On both clouds, a message can arrive more than once. On AWS, if one message in a batch fails, the whole batch is retried unless you &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-errorhandling.html" rel="noopener noreferrer"&gt;report which ones failed&lt;/a&gt;. If a handler sends an email or charges a card, save an ID so it never does it twice.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  APIs, Access and Identity
&lt;/h2&gt;

&lt;p&gt;Who can call what works on the same idea in both clouds. Only the names change:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;GCP&lt;/th&gt;
&lt;th&gt;AWS&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Service account on a service&lt;/td&gt;
&lt;td&gt;IAM role for the Lambda function or ECS task&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;roles/run.invoker&lt;/code&gt; on a service&lt;/td&gt;
&lt;td&gt;Lambda resource policy, or IAM login on a function URL&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Services calling each other with tokens&lt;/td&gt;
&lt;td&gt;IAM-signed calls, or a private API in API Gateway&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;"Allow unauthenticated"&lt;/td&gt;
&lt;td&gt;A public function URL or public API&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Identity-Aware Proxy&lt;/td&gt;
&lt;td&gt;Load balancer login with Amazon Cognito&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;API keys in API Gateway&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html" rel="noopener noreferrer"&gt;Usage plans and API keys&lt;/a&gt; in Amazon API Gateway&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Give each function or service its own IAM role, with only the access it needs. Don't make one big role for everything, even if the old apps shared one service account.&lt;/p&gt;

&lt;h2&gt;
  
  
  Networking You'll Trip Over
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Reaching private databases.&lt;/strong&gt; Cloud Run reaches your private network through a connector or Direct VPC egress. Lambda can &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html" rel="noopener noreferrer"&gt;join your VPC&lt;/a&gt; (your private network on AWS). ECS tasks run inside it already.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reaching the internet from the VPC.&lt;/strong&gt; A Lambda function inside a VPC cannot reach the internet on its own. It needs a NAT gateway, which costs money per hour and per GB. For AWS services like S3 and DynamoDB, use VPC endpoints instead. They are cheaper.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Custom domains.&lt;/strong&gt; A Cloud Run domain mapping becomes a certificate in ACM, plus a load balancer, CloudFront or an API Gateway custom domain.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Calls back to GCP.&lt;/strong&gt; During the move, some apps still call GCP. That is slower and costs money for data leaving GCP. Remove these calls first.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  A Simple Way to Decide
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm7qsaql6wqfe45wd7iqi.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm7qsaql6wqfe45wd7iqi.png" alt="Serverless decision flow: if it runs longer than 15 minutes, use ECS on Fargate or AWS Batch; if it is a web app with a connection pool or steady traffic, use ECS Express Mode; if it is a small API, webhook or event handler, use Lambda; if it is a scheduled job, use EventBridge Scheduler with Lambda or an ECS task; if it chains several steps, use Step Functions" width="800" height="496"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Does it run for more than 15 minutes?&lt;/strong&gt; Use ECS on Fargate or AWS Batch.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Is it a full web app&lt;/strong&gt; with a framework, a database or steady traffic? Use ECS Express Mode with the same container.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Is it a small API, webhook or event handler?&lt;/strong&gt; Use Lambda.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Does it run on a schedule?&lt;/strong&gt; Use EventBridge Scheduler to start a Lambda function or an ECS task.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Does it run several steps in a row, with retries and waits?&lt;/strong&gt; Use Step Functions.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  What Changes on the Bill
&lt;/h2&gt;

&lt;p&gt;Both clouds charge for the time your code runs and for each request. The details change the total:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Topic&lt;/th&gt;
&lt;th&gt;GCP&lt;/th&gt;
&lt;th&gt;AWS&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Pay per request&lt;/td&gt;
&lt;td&gt;Cloud Run: CPU time, memory time, requests&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://aws.amazon.com/lambda/pricing/" rel="noopener noreferrer"&gt;Lambda&lt;/a&gt;: memory time and requests&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Always-on containers&lt;/td&gt;
&lt;td&gt;Cloud Run instance billing&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://aws.amazon.com/fargate/pricing/" rel="noopener noreferrer"&gt;Fargate&lt;/a&gt;: CPU and memory per second, plus the load balancer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Staying warm&lt;/td&gt;
&lt;td&gt;Minimum instances (lower idle price)&lt;/td&gt;
&lt;td&gt;Provisioned concurrency (paid while it is on)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;APIs&lt;/td&gt;
&lt;td&gt;API Gateway per call&lt;/td&gt;
&lt;td&gt;API Gateway per call; HTTP APIs cost less than REST APIs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Events and queues&lt;/td&gt;
&lt;td&gt;Eventarc, Pub/Sub, Cloud Tasks&lt;/td&gt;
&lt;td&gt;EventBridge, SNS, SQS, all per request&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Discounts&lt;/td&gt;
&lt;td&gt;Committed use discounts&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://aws.amazon.com/savingsplans/compute-pricing/" rel="noopener noreferrer"&gt;Compute Savings Plans&lt;/a&gt; (cover Lambda and Fargate)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Three things catch teams out:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The load balancer.&lt;/strong&gt; ECS Express Mode puts a load balancer in front of your app. It costs money even with no traffic. Several apps can share one.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;NAT gateways.&lt;/strong&gt; Lambda functions in a VPC that call the internet go through NAT. A lot of outgoing traffic becomes a surprise on the bill.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Waiting time.&lt;/strong&gt; On Lambda you pay while your code waits for other services. An app that spends most of its time waiting may be cheaper on Fargate.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Run the new setup for a few weeks before you buy a Savings Plan. Real usage is the only good basis for a commitment.&lt;/p&gt;

&lt;h2&gt;
  
  
  What It Looks Like in Code
&lt;/h2&gt;

&lt;p&gt;A simple HTTP function on GCP and the same function on Lambda:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# GCP: Cloud Run function (Python)
import functions_framework

@functions_framework.http
def hello(request):
    name = request.args.get("name", "world")
    return {"message": f"Hello, {name}"}

# AWS: Lambda behind a function URL or HTTP API (Python)
import json

def handler(event, context):
    params = event.get("queryStringParameters") or {}
    name = params.get("name", "world")
    return {
        "statusCode": 200,
        "headers": {"Content-Type": "application/json"},
        "body": json.dumps({"message": f"Hello, {name}"}),
    }
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A function that reads Pub/Sub messages, and the same function reading from SQS:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# GCP: triggered by a Pub/Sub topic through Eventarc
import base64, json
import functions_framework

@functions_framework.cloud_event
def on_order(cloud_event):
    data = base64.b64decode(cloud_event.data["message"]["data"])
    process(json.loads(data))

# AWS: triggered by an SQS queue, with partial batch failures
import json

def handler(event, context):
    failed = []
    for record in event["Records"]:
        try:
            process(json.loads(record["body"]))
        except Exception:
            failed.append({"itemIdentifier": record["messageId"]})
    return {"batchItemFailures": failed}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And a Cloud Run service in Terraform, next to the same Lambda function:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;# GCP: a Cloud Run service
resource "google_cloud_run_v2_service" "api" {
  name     = "api"
  location = "us-central1"
  template {
    containers {
      image = "us-docker.pkg.dev/shop-prod/apps/api:1.4.2"
      resources { limits = { cpu = "1", memory = "512Mi" } }
    }
    scaling { min_instance_count = 1 }
    max_instance_request_concurrency = 80
    service_account = google_service_account.api.email
  }
}

# AWS: the same API as a Lambda function from a container image
resource "aws_lambda_function" "api" {
  function_name = "api"
  package_type  = "Image"
  image_uri     = "123456789012.dkr.ecr.us-east-1.amazonaws.com/api:1.4.2"
  memory_size   = 1024                    # CPU grows with memory
  timeout       = 30
  role          = aws_iam_role.api.arn    # was the service account
}

resource "aws_lambda_function_url" "api" {
  function_name      = aws_lambda_function.api.function_name
  authorization_type = "AWS_IAM"         # was roles/run.invoker
}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;These snippets show the shape, not every setting. Check the current docs before you copy them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Things That Bite Later
&lt;/h2&gt;

&lt;blockquote&gt;
&lt;p&gt;"Failures are a given and everything will eventually fail over time."&lt;/p&gt;

&lt;p&gt;— &lt;strong&gt;Werner Vogels&lt;/strong&gt;, CTO of Amazon, in &lt;a href="https://www.allthingsdistributed.com/2016/03/10-lessons-from-10-years-of-aws.html" rel="noopener noreferrer"&gt;&lt;em&gt;10 Lessons from 10 Years of AWS&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;These are the small things that tend to break after the move:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Timeouts in a chain.&lt;/strong&gt; API Gateway REST APIs stop waiting after &lt;a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-execution-service-limits-table.html" rel="noopener noreferrer"&gt;29 seconds by default&lt;/a&gt;. A Lambda behind it can run longer, but the caller has already given up. Check every timeout from the user to the database.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Large uploads.&lt;/strong&gt; Lambda takes up to 6 MB per normal request. Big file uploads that worked on Cloud Run should go straight to S3 with a &lt;a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html" rel="noopener noreferrer"&gt;pre-signed URL&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Things kept in memory.&lt;/strong&gt; Code that keeps a cache or a counter in memory acts differently when every request has its own copy of the app.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Logs and alerts.&lt;/strong&gt; Cloud Logging searches and alerts become &lt;a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html" rel="noopener noreferrer"&gt;CloudWatch Logs Insights&lt;/a&gt; queries and CloudWatch alarms. Rebuild the alerts people rely on before you move traffic.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Secrets.&lt;/strong&gt; Secret Manager paths like &lt;code&gt;projects/.../secrets/...&lt;/code&gt; become &lt;a href="https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html" rel="noopener noreferrer"&gt;Secrets Manager&lt;/a&gt; or Parameter Store names. Search your code for all of them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Limits.&lt;/strong&gt; New AWS accounts start with a low Lambda concurrency limit. Ask for more weeks before you move real traffic.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Doing the Move, Step by Step
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;List everything.&lt;/strong&gt; Every Cloud Run service and job, function, App Engine app, trigger, queue, schedule and workflow, with its traffic, run time, cost and owner.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pick the AWS service&lt;/strong&gt; for each one, using the questions above. Write down why.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Build the base:&lt;/strong&gt; AWS accounts, networks, a container registry (ECR), IAM roles, logs, alarms and higher limits. The &lt;a href="https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/welcome.html" rel="noopener noreferrer"&gt;Serverless Applications Lens&lt;/a&gt; is a good checklist.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Start with one small app.&lt;/strong&gt; Move it end to end: code, triggers, secrets, alarms and domain.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Run both clouds side by side.&lt;/strong&gt; Send a small share of users to AWS using &lt;a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html" rel="noopener noreferrer"&gt;weighted DNS in Route 53&lt;/a&gt;. Compare errors and speed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Move the events.&lt;/strong&gt; Point schedules and queues at AWS one at a time. Empty the GCP queues before you turn them off.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Clean up.&lt;/strong&gt; Turn off the GCP services, delete old service accounts and keys, and buy Savings Plans once usage is steady.&lt;/li&gt;
&lt;/ol&gt;

&lt;blockquote&gt;
&lt;p&gt;"Serverless is still the future because the mindset shift is the thing we haven't gotten to."&lt;/p&gt;

&lt;p&gt;— &lt;strong&gt;Ben Kehoe&lt;/strong&gt;, AWS Serverless Hero, speaking to &lt;a href="https://sdtimes.com/cloud/sd-times-blog-getting-a-serverless-reality-check/" rel="noopener noreferrer"&gt;&lt;em&gt;SD Times&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Serverless is often the fastest part of a cloud move, because there are no servers to copy. The work is in the default settings: how many requests one copy takes, how long a request may run, and how events are retried. Get those right, and the rest is mostly config.&lt;/p&gt;

&lt;h2&gt;
  
  
  Common Questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is the Cloud Run equivalent in AWS?
&lt;/h3&gt;

&lt;p&gt;ECS Express Mode is the closest: same container, one copy serving many requests, with AWS setting up Fargate, the load balancer and scaling. AWS Lambda fits small APIs and bursty traffic. App Runner is another option for simple web apps.&lt;/p&gt;

&lt;h3&gt;
  
  
  Cloud Run vs Lambda: which should I pick?
&lt;/h3&gt;

&lt;p&gt;Pick Lambda for small APIs, webhooks and event handlers that can scale to zero. Pick ECS for full web apps, steady traffic, requests longer than 15 minutes, or bodies over 6 MB. Watch database connections: on Lambda every request is its own copy, so use RDS Proxy.&lt;/p&gt;

&lt;h3&gt;
  
  
  Cloud Run vs Fargate: what changes?
&lt;/h3&gt;

&lt;p&gt;ECS on Fargate runs the same container, but it does not scale to zero, so at least one task runs all the time and a load balancer sits in front of it. In return you get long requests and many requests per copy, like Cloud Run.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do I migrate Cloud Functions to Lambda?
&lt;/h3&gt;

&lt;p&gt;The business logic usually stays. What changes is the entry point (Functions Framework becomes &lt;code&gt;handler(event, context)&lt;/code&gt;), the trigger (Eventarc or Pub/Sub becomes SQS, SNS or EventBridge), and the 15-minute run limit. Keep the logic in its own file and write a thin entry point for each cloud.&lt;/p&gt;

&lt;h3&gt;
  
  
  Eventarc vs EventBridge: what is different?
&lt;/h3&gt;

&lt;p&gt;Eventarc sends CloudEvents. EventBridge uses its own shape with &lt;code&gt;source&lt;/code&gt;, &lt;code&gt;detail-type&lt;/code&gt; and &lt;code&gt;detail&lt;/code&gt;. Every function that reads an event needs a small change.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the Cloud Tasks equivalent in AWS?
&lt;/h3&gt;

&lt;p&gt;Amazon SQS with Lambda. SQS holds the tasks but does not call anything, so Lambda reads the queue, and the maximum concurrency setting controls the rate. Failed tasks go to a dead-letter queue.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the App Engine equivalent in AWS?
&lt;/h3&gt;

&lt;p&gt;App Engine flexible moves to ECS on Fargate or Elastic Beanstalk. Standard apps on newer runtimes go in a container. Older apps that use Memcache, Task Queues, Users or Datastore need ElastiCache, SQS, Cognito and DynamoDB. &lt;code&gt;cron.yaml&lt;/code&gt; becomes EventBridge Scheduler.&lt;/p&gt;

&lt;h2&gt;
  
  
  About MigrateX
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxywolgtbstuveflre5yv.png" alt="MigrateX" width="799" height="293"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;MigrateX is our platform and service for moving software, data and infrastructure from one technology to another. It combines automation with experienced engineers. The automation does the repetitive work quickly, and the engineers make the tricky decisions.&lt;/p&gt;

&lt;p&gt;Here's how we run a GCP to AWS serverless move with MigrateX:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Assessment.&lt;/strong&gt; We list every Cloud Run service, function, App Engine app, trigger, queue, schedule and workflow, with its traffic, run time, cost and owner. You see where the work is before anyone agrees on a timeline.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan.&lt;/strong&gt; We work with your team to pick the AWS target for each service, design the IAM roles and networking, and decide the order of the move.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Migration, step by step.&lt;/strong&gt; Automation does the repetitive parts: rewriting handlers and event formats, turning Cloud Run and App Engine config into ECS, Lambda and EventBridge, and converting Terraform. Our engineers handle the parts that need thought: long-running work, concurrency, App Engine bundled services and Workflows.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Proof that it works.&lt;/strong&gt; Both clouds run side by side. We shift traffic a little at a time and compare errors, response times and costs before each step.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Handover and clean-up.&lt;/strong&gt; We turn off GCP services one at a time, set up Savings Plans once usage is steady, and leave your team with a setup they understand and own.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;What you get along the way:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No big-bang switch.&lt;/strong&gt; Traffic moves a little at a time, with a quick way back.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No lost events.&lt;/strong&gt; Queues and schedules move one at a time and are drained before anything is turned off.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A smaller bill, not a bigger one.&lt;/strong&gt; Right-sized functions, shared load balancers and Savings Plans are part of the move, not an afterthought.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One partner for the whole move.&lt;/strong&gt; The same team and approach covers your serverless apps, your compute and your data.&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;Planning a move from GCP to AWS? We'd love to hear about it. Tell us a little about your setup through &lt;a href="https://cobuildx.ai/contact" rel="noopener noreferrer"&gt;Contact Us&lt;/a&gt;, and we'll start with a free chat about where the work is likely to be.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;h3&gt;
  
  
  AWS
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;AWS. &lt;em&gt;AWS App Runner availability change&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/apprunner/latest/dg/apprunner-availability-change.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/apprunner/latest/dg/apprunner-availability-change.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon ECS Express Mode&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/express-service-overview.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonECS/latest/developerguide/express-service-overview.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;AWS Fargate for Amazon ECS&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Understanding Lambda function scaling&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Lambda Managed Instances&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-managed-instances.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/lambda-managed-instances.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Create a Lambda function using a container image&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/images-create.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/images-create.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Lambda SnapStart&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Using Lambda with Amazon SQS&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Handling errors for an SQS event source in Lambda&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-errorhandling.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-errorhandling.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Giving Lambda functions access to resources in a VPC&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon EventBridge&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon EventBridge Scheduler&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;AWS Step Functions&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;AWS Batch&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/batch/latest/userguide/what-is-batch.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/batch/latest/userguide/what-is-batch.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Amazon RDS Proxy&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Lambda quotas&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Provisioned concurrency for Lambda&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Quotas for REST APIs in API Gateway&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-execution-service-limits-table.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-execution-service-limits-table.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Serverless Applications Lens, AWS Well-Architected&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/welcome.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/welcome.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;Weighted routing in Route 53&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;AWS. &lt;em&gt;AWS Elastic Beanstalk&lt;/em&gt;. &lt;a href="https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/Welcome.html" rel="noopener noreferrer"&gt;https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/Welcome.html&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Expert sources
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Ben Kehoe. &lt;em&gt;Serverless as a mindset&lt;/em&gt;. Serverless Boston meetup talk. &lt;a href="https://www.meetup.com/serverless-boston/events/262376552/" rel="noopener noreferrer"&gt;https://www.meetup.com/serverless-boston/events/262376552/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Ben Kehoe, quoted in &lt;em&gt;Getting a serverless reality check&lt;/em&gt;. SD Times. &lt;a href="https://sdtimes.com/cloud/sd-times-blog-getting-a-serverless-reality-check/" rel="noopener noreferrer"&gt;https://sdtimes.com/cloud/sd-times-blog-getting-a-serverless-reality-check/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Yan Cui. &lt;em&gt;Running Serverless at Scale&lt;/em&gt;. &lt;a href="https://www.slideshare.net/theburningmonk/running-serverless-at-scale" rel="noopener noreferrer"&gt;https://www.slideshare.net/theburningmonk/running-serverless-at-scale&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Werner Vogels. &lt;em&gt;10 Lessons from 10 Years of Amazon Web Services&lt;/em&gt;. All Things Distributed, 2016. &lt;a href="https://www.allthingsdistributed.com/2016/03/10-lessons-from-10-years-of-aws.html" rel="noopener noreferrer"&gt;https://www.allthingsdistributed.com/2016/03/10-lessons-from-10-years-of-aws.html&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Google Cloud
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Run quotas and limits&lt;/em&gt;. &lt;a href="https://cloud.google.com/run/quotas" rel="noopener noreferrer"&gt;https://cloud.google.com/run/quotas&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Maximum concurrent requests for services&lt;/em&gt;. &lt;a href="https://cloud.google.com/run/docs/about-concurrency" rel="noopener noreferrer"&gt;https://cloud.google.com/run/docs/about-concurrency&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Google Cloud. &lt;em&gt;Cloud Run functions overview&lt;/em&gt;. &lt;a href="https://cloud.google.com/functions/docs/concepts/overview" rel="noopener noreferrer"&gt;https://cloud.google.com/functions/docs/concepts/overview&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;CobuildX helps teams migrate legacy applications and cloud infrastructure with &lt;a href="https://cobuildx.ai/migratex" rel="noopener noreferrer"&gt;MigrateX&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on the &lt;a href="https://cobuildx.ai/blog/gcp-to-aws-serverless" rel="noopener noreferrer"&gt;CobuildX blog&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>aws</category>
      <category>googlecloud</category>
      <category>serverless</category>
      <category>cloud</category>
    </item>
  </channel>
</rss>
