case study / EUNX (freelance) · 2024
From private GKE to AWS EKS
Built a multi-service platform on private GKE from scratch, then moved it to AWS EKS by mapping capabilities, not resource names.
- Client
- EUNX (freelance)
- Period
- 2024
- Role
- DevOps Engineer
- Result
- full platform migration
- Stack
- GKE, EKS, Terraform, Helm, Argo CD, External Secrets, Apigee
In short
- Built the first private GKE platform for EUNX from the ground up, with Terraform, Helm, Apigee and SAST in the pipelines.
- Moved its environments to AWS EKS with Argo CD, a WAF in front of the load balancers, workload IAM roles and External Secrets.
- Treated the move as a platform migration (identity, secrets, ingress, delivery, observability), not a cluster copy.
Context
EUNX ran containerized services on GCP: private GKE networking, Terraform-managed infrastructure, reusable Helm charts, CI pipelines with security scanning, Google Apigee for API policies, and separate environments with different release rules. I built that platform, and later the environments had to move to AWS. The target was not “the same YAML on EKS” but an AWS-native operating model.
Constraints
- Application teams should change as little as possible.
- Workloads had to keep least-privilege cloud access, not inherit broad node permissions.
- Secrets could not end up in Git or in pipelines.
- Rollback had to stay possible until production traffic had fully moved.
Decisions
Map capabilities, not resource names
| Platform concern | GCP | AWS |
|---|---|---|
| Kubernetes | Private GKE | EKS |
| Workload identity | GKE Workload Identity | IRSA or EKS Pod Identity |
| Secrets | Google Secret Manager | AWS Secrets Manager or Parameter Store |
| Ingress | GKE load balancing | AWS Load Balancer Controller, behind a WAF |
| Packaging | Helm | Helm |
| Deployment | CI-driven releases | Argo CD GitOps |
| Infrastructure | Terraform | Terraform |
Terraform and Helm stayed the interfaces application teams already knew. Only the provider details underneath them changed.
Inventory before provisioning
Before building EKS, I listed everything that could stop a workload from becoming healthy: registries and image-pull permissions, ingress, certificates and DNS, persistent storage, database and third-party network paths, secrets and their refresh, service accounts and cloud API permissions, scheduled jobs, health checks and autoscaling, and who owns which alerts. A deployment can be valid YAML and still fail because one route, identity or DNS record was not recreated.
Foundation first
The EKS platform was running before any application moved: VPC and private subnets, EKS and worker capacity, registry access, the AWS Load Balancer Controller, DNS and certificates, autoscaling, central logging and metrics, Argo CD and External Secrets. Terraform owned the cloud resources, and cluster add-ons went in a fixed order so releases never raced a missing controller.
Identity per workload
Copying broad node permissions would have been faster and weaker. Each workload got only the AWS permissions it needed, by mapping its Kubernetes service account to a dedicated IAM role with IRSA or EKS Pod Identity. The rule: two services with different jobs do not share a cloud role. That keeps permission reviews and incident analysis clear.
Secrets stay outside Git
External Secrets kept one Kubernetes-facing interface while the backend changed from Google Secret Manager to AWS:
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
name: payments-api
spec:
refreshInterval: 1h
secretStoreRef:
name: aws-secrets
kind: ClusterSecretStore
target:
name: payments-api-runtime
data:
- secretKey: database-url
remoteRef:
key: production/payments-api
property: database_url
The paths are the easy part. Rotation ownership, refresh intervals, failure alerts and behavior when a secret is missing at deploy time were defined too.
Separate build from deployment
CI builds, tests, scans and publishes immutable images. Git records the desired version per environment, and Argo CD reconciles the cluster to it, automatically in lower environments and with approval in production. That removed cloud-specific logic from application pipelines and made every deployment auditable.
Move in small, verifiable steps
The order followed dependencies, not repositories: platform controllers and observability, stateless internal services, public services and ingress, scheduled and async workloads, services with persistent or external dependencies, and finally production traffic and DNS. Each workload was checked for readiness, secret sync, cloud API access, service discovery, external connectivity, ingress health, logs and alerts, and rollback to the old environment. Both platforms ran side by side until cutover.
Results
- All environments moved from GCP/GKE to AWS EKS, with Terraform, Helm and Argo CD as the source of truth.
- Every workload runs with its own IAM role; no broad node permissions.
- No secrets in repositories or pipelines.
- Observability and rollback were in place before production traffic moved.
Pitfalls worth avoiding
- Treating EKS as GKE with new names. Controllers, identities, load balancers, storage classes and networking differ.
- Granting permissions to nodes instead of workloads. Tests pass early, but access becomes broad and hard to audit.
- Adding observability after cutover. A green deployment is not enough before production traffic moves.
- Manual cluster changes during the move. Keep Terraform, Helm and Argo CD as the source of truth.
- Migrating everything at once. Small units give clean rollback points and faster feedback.