GKE Autopilot for Australian Startups: A Practical Guide
When an Australian startup should move from Cloud Run to GKE Autopilot, with Terraform, Workload Identity and Cloud SQL setup, plus real cost trade-offs.
Short answer: Move to GKE Autopilot when your startup needs Kubernetes features that Cloud Run does not provide, such as sidecars, custom networking or fine-grained traffic control, and you do not have a dedicated platform team. A regional Autopilot cluster in Sydney, with Workload Identity and private Cloud SQL, gives you that control without the node management and cost creep of a typical enterprise setup.
Cloud Run handles a lot of traffic, so request volume is rarely the real reason to change. Teams usually move because they need deeper control over orchestration, networking and routing. That means Google Kubernetes Engine (GKE).
For Australian teams, GKE brings a few specific constraints. Workloads often span Sydney (australia-southeast1) and Melbourne (australia-southeast2) and need to meet the Australian Privacy Principles (APPs) and the ACSC Essential Eight.
A traditional enterprise consultancy can make this worse. They tend to deploy GKE Standard clusters with custom node pools, Anthos Service Mesh and third-party monitoring agents. In one engagement we reviewed, monthly cloud spend rose from $4,800 AUD to $23,400 AUD with no measurable gain in application performance.
The aim is to adopt GKE without taking on operational cost you do not need. If you are comparing partners, our guide to choosing a Google Cloud migration partner covers what to ask.
Architecture and design trade-offs
A lean setup uses regional GKE Autopilot, Workload Identity Federation for GKE, and private IP connectivity to Cloud SQL.
Autopilot removes node operating system patching and cluster maintenance. Workload Identity lets pods call Google Cloud APIs without static JSON service account keys. Private IP keeps database traffic off the public internet.
| Design area | Typical enterprise pattern | Lean startup pattern | Trade-off |
|---|---|---|---|
| Cluster engine | GKE Standard with custom node pools | Regional GKE Autopilot | Autopilot removes node patching but restricts host-level DaemonSets |
| Identity | Stored service account JSON keys | Workload Identity Federation | No long-lived keys to leak or rotate |
| Database access | Public IP with authorised networks | Private IP with Cloud SQL Auth Proxy | Database traffic stays inside the VPC without VPN tunnels |
| Monthly cost (example engagement) | $22,000 to $28,000 AUD | $6,200 to $7,800 AUD | Less idle capacity and fewer paid add-ons |
Autopilot does not suit every workload. If your application needs host-level access, custom kernel settings or unsupported DaemonSets, use GKE Standard.
Planning cluster networking? Our GKE IP address calculator sizes pod and service ranges for you.
Step by step implementation
This is how we set up the stack with Terraform and Kubernetes manifests rather than clicking through the console.
Prerequisites
- Terraform 1.8 or later
- Google Cloud provider version 5.30 or later
- A VPC in
australia-southeast1with secondary IP ranges for pods and services - IAM permissions for cluster creation, Workload Identity and Cloud SQL
Step 1: Provision GKE Autopilot with Terraform
Deploy a private regional cluster in Sydney with secondary IP ranges:
resource "google_container_cluster" "primary" {
name = "prod-syd-cluster"
location = "australia-southeast1"
enable_autopilot = true
network = google_compute_network.vpc.id
subnetwork = google_compute_subnetwork.subnet.id
ip_allocation_policy {
cluster_secondary_range_name = "pods"
services_secondary_range_name = "services"
}
private_cluster_config {
enable_private_nodes = true
enable_private_endpoint = false
master_ipv4_cidr_block = "172.16.0.0/28"
}
}
Step 2: Bind Workload Identity
Connect your Kubernetes service account to a Google Cloud IAM service account. There are no long-lived JSON keys to leak or rotate.
gcloud iam service-accounts add-iam-policy-binding backend-sa@my-app.iam.gserviceaccount.com \
--role="roles/iam.workloadIdentityUser" \
--member="serviceAccount:my-app.svc.id.goog[production/backend-ksa]"
Then annotate the Kubernetes service account:
apiVersion: v1
kind: ServiceAccount
metadata:
name: backend-ksa
namespace: production
annotations:
iam.gke.io/gcp-service-account: backend-sa@my-app.iam.gserviceaccount.com
Step 3: Connect to Cloud SQL over private IP
Run the Cloud SQL Auth Proxy as a sidecar next to your service container:
containers:
- name: cloud-sql-proxy
image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.11.0
args: ["--private-ip", "my-app:australia-southeast1:prod-db"]
resources:
requests:
cpu: "100m"
memory: "128Mi"
Edge cases and failure modes
Even a lean GKE setup needs planning around networking, sizing and updates.
1. Cross-region egress charges
Synchronous replication between Sydney and Melbourne adds up quickly. Moving 150 TB a month across regions at about $0.01 USD per GB costs roughly $2,300 AUD in network charges alone, based on exchange rates at the time of writing. Use asynchronous read replicas and serve reads locally where some replication lag is acceptable.
2. Autopilot resource adjustments
Autopilot enforces CPU to memory ratios. If you request 0.25 vCPU and 4 GiB of memory, Autopilot raises the CPU request to meet the minimum ratio, which increases your bill. Check pod resource requests against the Autopilot compute classes before you deploy.
3. Maintenance windows and patch deadlines
The Essential Eight expects critical vulnerabilities to be patched quickly, within 48 hours where an exploit exists, but cluster upgrades can interrupt traffic. For a business operating 09:00 to 17:00 AEST, set a maintenance window between 00:00 and 04:00 AEST, Tuesday to Thursday.
Verification and benchmarks
These figures come from one engagement where 14 microservices moved from Compute Engine VMs to GKE Autopilot. Your results will depend on workload and configuration.
| Metric | Baseline VMs | Enterprise scope | GKE Autopilot (target) |
|---|---|---|---|
| p99 latency (14,000 QPS) | 380 ms | 290 ms | 64 ms |
| Deployment duration | 270 min | 45 min | 8 min |
| Monthly cloud spend | $4,800 AUD | $23,400 AUD | $6,450 AUD |
| Node recovery time | 18 min | 8 min | 42 sec |
When to adopt GKE, and when to skip it
Adopt GKE Autopilot if:
- You need multi-container pods, sidecars, microservice networking or private database links that Cloud Run does not cover.
- Enterprise customers ask for Essential Eight or SOC 2 controls and you need consistent policy across services.
- You do not have a dedicated platform engineer and want Google to manage nodes.
Stay on Cloud Run if:
- Your services are stateless HTTP or event-driven containers and you do not need sidecars, daemon processes or custom networking.
- Traffic is modest or spiky and you want to avoid cluster fees and operational overhead.
Moving to Kubernetes is an architectural commitment, not a deployment checkbox. Choose a partner who keeps the platform lean and the bill predictable. See how we work as a Google Cloud Premier Partner or review our landing zone approach.
Plan your GKE architecture
If you want to scale on Google Cloud without enterprise overhead, we can review your design.
Engineering consultant at Aviato Consulting specializing in cloud infrastructure, security, and agentic AI systems on Google Cloud.
Related Articles
Choosing a Google Cloud Migration Partner in Australia
How to compare Google Cloud migration partners in Australia: RaMP funding, Essential Eight, data residency, code ownership and handover, with a scorecard.
Your gcloud login works. Your Python doesnβt. Hereβs why.
Why gcloud auth login works in your terminal while Vertex AI fails in Python, and the four commands that fix Application Default Credentials (ADC).
Governing AI at Scale in Financial Services
Banks and insurers have proven AI works. The next question is whether they can run thousands of agents and still show a regulator exactly what each one did. A seven control framework and a 90 day plan for APRA, MAS, RBI and BNM expectations on Google Cloud.