Skip to content
Aviato Consulting
#GoogleCloud β€’ β€’ 6 min read

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 areaTypical enterprise patternLean startup patternTrade-off
Cluster engineGKE Standard with custom node poolsRegional GKE AutopilotAutopilot removes node patching but restricts host-level DaemonSets
IdentityStored service account JSON keysWorkload Identity FederationNo long-lived keys to leak or rotate
Database accessPublic IP with authorised networksPrivate IP with Cloud SQL Auth ProxyDatabase traffic stays inside the VPC without VPN tunnels
Monthly cost (example engagement)$22,000 to $28,000 AUD$6,200 to $7,800 AUDLess 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-southeast1 with 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.

MetricBaseline VMsEnterprise scopeGKE Autopilot (target)
p99 latency (14,000 QPS)380 ms290 ms64 ms
Deployment duration270 min45 min8 min
Monthly cloud spend$4,800 AUD$23,400 AUD$6,450 AUD
Node recovery time18 min8 min42 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.

Tags: #Google Cloud #GKE #Kubernetes #Startups #Australia
Written by

Google Cloud Specialists

Engineering consultant at Aviato Consulting specializing in cloud infrastructure, security, and agentic AI systems on Google Cloud.

Keep Reading
#GoogleCloud

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.

FAQ

Frequently Asked Questions

When should an Australian startup move from Cloud Run to GKE Autopilot?

Move when you need things Cloud Run does not offer, such as sidecar-heavy pods, custom networking, fine-grained traffic routing or a consistent Kubernetes platform across many services. Traffic volume alone is not the trigger. Cloud Run is simpler and has no cluster fee, so stay on it until a specific requirement forces the change.

Is GKE Autopilot cheaper than GKE Standard?

Often, for teams without dedicated platform engineers. Autopilot bills for the CPU, memory and storage your pods request, so you do not pay for idle nodes, and Google handles node patching. Standard can still be cheaper for steady, well-packed workloads that need custom node pools, but it needs engineering time to run.

Can GKE meet the ACSC Essential Eight and Australian data residency?

Yes, with the right configuration. Run regional clusters in australia-southeast1 (Sydney) or australia-southeast2 (Melbourne), restrict resource locations with Organization Policy, use Workload Identity Federation instead of static keys, and set maintenance windows so patching happens on a schedule you control.

What does Autopilot not support?

Autopilot restricts host-level access. If you need privileged containers, custom kernel settings or DaemonSets that depend on host access, use GKE Standard.

How do pods connect to Cloud SQL without public IPs?

Use a private IP Cloud SQL instance and run the Cloud SQL Auth Proxy as a sidecar with the --private-ip flag. Combined with Workload Identity, no database credentials or service account keys need to be stored in the cluster.

Talk to an architect who has done this before.

Bring your current setup and the outcome you need. You will get a view on the approach, the risks and roughly what it costs.

Book a 20-min architecture call

Straight to a senior GCP architect. No SDR, no slide deck.

Not ready to talk? See how we migrated Hapana off AWS β†’

Or call +61 2 8359 9507 · Hello@aviato.consulting

Call us Book a call

Quick navigation