Chinese
Uncategorized

GKE Agentic Migration: Let the Agent Read IaC Before It Touches a Cluster

Google Cloud’s GKE Agentic Migration is aimed at reviewable EKS-to-GKE work. The first win is offline validation, not autonomy.

Jacky Wang 4 min read 53 views

The Kubernetes migration sentence I dislike most is: “Let the agent take a look at the cluster.” What does it read? Which identity does it use? Can it make a change while it is investigating? Those details are often left vague. Google Cloud recently listed GKE Agentic Migration in Public Preview. It is an open-source agent plugin for EKS-to-GKE migration that runs in a local development harness, indexes source infrastructure-as-code, maps cloud-specific primitives, and validates configuration and migration runbooks. Google’s description explicitly says it delivers this work with zero live cluster mutations.

That boundary matters. The first output from a migration agent should be a reviewable pull request and a data-migration runbook, not a sequence of already-executed kubectl commands. For stateful services, ingress, storage classes, and IAM, explaining why a change is needed is more valuable than producing another YAML file.

Keep the inputs local and explicit

I would not start by giving the agent a cloud account. I would assemble the inputs first: Terraform, Helm values, Kustomize overlays, cluster versions, and the cloud services the workload depends on. Secrets should be replaced with placeholders. A basic inventory could begin like this:

git grep -nE 'eks|karpenter|iam|storageClass|ingress' -- \
  '*.tf' '*.yaml' '*.yml' 'Chart.yaml' 'values*.yaml'

This command does not migrate anything. It makes hidden assumptions visible. Karpenter, node configuration, load balancers, storage, and identity on EKS are not automatically equivalent just because the destination is also Kubernetes. An agent can help build a mapping table; I would still split each mapping into a reviewable change.

Offline validation is the right first version of autonomy

Google describes deterministic guardrails, offline validation, reviewable pull requests, and migration runbooks. I read that as a pre-migration analysis layer, not as an operator with cluster-admin access.

The workflow can stay simple. Generate a candidate patch. Run schema and policy checks. Test the application in an isolated environment. Only then enter a human-approved deployment process. Anything that needs real secrets, production Pod access, or writes to a CRD should be a separate, explicitly authorized phase.

I would also keep a “do not migrate yet” list. An AWS managed service may not have a direct GCP equivalent. An admission policy may depend on an identity model that changes during the move. Having the agent say “this cannot be mapped reliably” and stop is often better than receiving a complete-looking conversion file.

Running Pods are not the acceptance test

A green deployment can make a cloud migration look finished too early. Acceptance needs to cover data, network behavior, permissions, and rollback. Does the StatefulSet preserve volume semantics? Does the ingress health check behave the same way? Does the service account have only the access it needs? Can the old environment take traffic again within a defined window?

For each service, I would keep a small migration record instead of relying on a chat transcript:

service=payments-api
source=eks/prod
target=gke/staging
data_check=checksum + application read
rollback=restore old deployment manifest
approval=required

I would also avoid reading Public Preview as a production guarantee. Google describes the plugin as a preview and emphasizes that the workflow does not mutate a live cluster. That is exactly why I would try it—and exactly why I would not connect it to a production kubeconfig.

My prediction is that migration agents will become reliable first as incompatibility detectors, not as unattended cluster movers. If an agent can turn dozens of hidden cloud assumptions into small, understandable pull requests, that is already a strong result. I would test it in an isolated staging repository, require human review of every output, and only then decide whether to expand its scope.

That also changes how I would stage a migration. I would begin with a stateless service that has a clean rollback and no cross-cloud database dependency. I would record its baseline, then add storage and ingress as separate changes. The first measure is not how quickly the agent writes YAML. It is whether the tool exposes uncertainty and keeps each decision in version control.

For a real cutover, I would add an application-level read test after the infrastructure checks. A cluster can accept every manifest and still serve stale data, reject callbacks, or lose an important network path. Those failures belong in the migration evidence, not in a later incident report.

Primary references: Google Cloud’s latest announcements and Google Cloud Modernize.

发表评论