Study guide
10.3 Infrastructure as Code: Terraform, Config Connector, Cloud Foundation Toolkit & Helm
Google Cloud Associate Cloud Engineer ACE
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Introduction & Exam Overview
1.1 About the GCP Associate Cloud Engineer Exam 1.2 How to Use This Study Guide & Build a Study Plan
2 Chapter 2: Resource Hierarchy, IAM Basics & Cloud Identity
2.1 The GCP Resource Hierarchy: Organizations, Folders & Projects 2.2 Organization Policies & Granting IAM Roles 2.3 Cloud Identity: Managing Users and Groups
3 Chapter 3: APIs, Quotas & Billing Configuration
3.1 Enabling APIs and Provisioning Cloud Operations Suite 3.2 Assessing and Requesting Quota Increases 3.3 Billing Accounts, Project Linking & Billing Exports 3.4 Billing Budgets and Alerts
4 Chapter 4: Planning Compute & Storage Resources
4.1 Choosing the Right Compute Option: GCE vs. GKE vs. Cloud Run vs. Cloud Functions 4.2 Spot VMs, Custom Machine Types & Cost-Optimized Compute Planning 4.3 Choosing a Data Storage Product: Cloud SQL, BigQuery, Firestore, Spanner & Bigtable 4.4 Cloud Storage Classes & Persistent Disk Types
5 Chapter 5: Planning Network Resources
5.1 Load Balancing Options and Use Cases 5.2 Regional Resource Placement & High Availability Planning 5.3 Network Service Tiers: Premium vs. Standard
6 Chapter 6: Deploying Compute Engine Workloads
6.1 Launching Compute Engine Instances: Disks, SSH Keys & Availability Policies 6.2 Managed Instance Groups, Instance Templates & Autoscaling 6.3 OS Login and VM Manager for Fleet Configuration
7 Chapter 7: Deploying Google Kubernetes Engine Workloads
7.1 Installing and Configuring kubectl 7.2 Deploying GKE Clusters: Autopilot, Regional, Private & GKE Enterprise 7.3 Deploying Containerized Applications to GKE
8 Chapter 8: Deploying Serverless & Event-Driven Applications
8.1 Deploying Applications to Cloud Run and Cloud Functions 8.2 Event-Driven Architectures: Pub/Sub, Cloud Storage Triggers & Eventarc
9 Chapter 9: Deploying Data Solutions
9.1 Deploying Data Products: Cloud SQL, Firestore, Spanner, BigQuery & AlloyDB 9.2 Deploying Pub/Sub, Dataflow & Loading Data into Google Cloud
10 Chapter 10: Deploying Networking Resources & Infrastructure as Code
10.1 Creating VPCs, Subnets & Shared VPC 10.2 Firewall Rules, Cloud VPN & VPC Network Peering 10.3 Infrastructure as Code: Terraform, Config Connector, Cloud Foundation Toolkit & Helm
11 Chapter 11: Managing Compute Engine & GKE in Production
11.1 Connecting to and Managing Running Compute Engine Instances 11.2 Working with Snapshots and Custom Images 11.3 Managing GKE Clusters: Node Pools, Workloads & Artifact Registry Access 11.4 Horizontal and Vertical Pod Autoscaling in GKE
12 Chapter 12: Managing Cloud Run, Storage & Database Operations
12.1 Managing Cloud Run Revisions, Traffic Splitting & Scaling 12.2 Managing and Securing Cloud Storage Objects & Lifecycle Policies 12.3 Querying, Estimating Costs, Backup & Job Monitoring for Databases (Cloud SQL, BigQuery, Spanner, Dataflow)
13 Chapter 13: Networking Operations, Monitoring & Logging
13.1 Networking Operations: Subnets, Static IPs, Cloud DNS & Cloud NAT 13.2 Cloud Monitoring: Alerts, Custom Metrics & Dashboards 13.3 Cloud Logging: Buckets, Log Analytics, Routers & Filtering 13.4 Diagnostics, Ops Agent, Managed Service for Prometheus & Audit Logs
14 Chapter 14: IAM Policies & Role Types
14.1 IAM Policies: Structure, Bindings & Policy Hierarchy 14.2 IAM Role Types: Basic, Predefined & Custom Roles
15 Chapter 15: Service Accounts & Security Configuration
15.1 Creating Service Accounts & Assigning Least-Privilege Permissions 15.2 Assigning Service Accounts to Resources & Managing SA IAM Policies 15.3 Service Account Impersonation & Short-Lived Credentials
16 Chapter 16: Exam Readiness — Scenarios & Test-Day Strategy
16.1 Common ACE Exam Scenarios & Decision Frameworks 16.2 Test-Day Logistics, Time Management & Final Review Checklist
10.3 Infrastructure as Code: Terraform, Config Connector, Cloud Foundation Toolkit & Helm
Key Takeaways Explain This Topic AI
The exam guide names exactly four IaC tools for this bullet: Cloud Foundation Toolkit, Config Connector, Terraform, and Helm.
Terraform is a general-purpose, multi-cloud declarative IaC engine using HCL and a state file, with a plan/apply workflow.
Cloud Foundation Toolkit is a library of Google-curated Terraform modules (project factory, network, IAM patterns), not a separate engine.
Config Connector manages GCP resources as Kubernetes CRDs with continuous, controller-based reconciliation, unlike Terraform's point-in-time apply model.
Helm is Kubernetes's package manager for templating and versioning application releases inside a cluster; it does not provision the surrounding GCP infrastructure.
Last updated: July 2026
Why This Matters on the ACE Exam
The exam guide's Domain 3 closes with a short but sharply-defined bullet: "infrastructure as code tooling (e.g., Cloud Foundation Toolkit, Config Connector, Terraform, Helm)." Unlike most ACE content, which tests doing a task in the Console or with gcloud , this sub-topic tests recognition — can you correctly identify which of these four named tools solves a given infrastructure-as-code problem, and how they relate to each other. Confusing the four with each other (or with Cloud Deployment Manager, which is not in this official bullet) is the most common way candidates lose points here.
The Four Named Tools
Terraform is an open-source, cloud-agnostic declarative infrastructure-as-code tool built by HashiCorp. You write infrastructure definitions in HashiCorp Configuration Language (HCL) , and Terraform maintains a state file that tracks what it believes exists in the real world. The core workflow is three commands: terraform init # download providers (google, google-beta), initialize backend
- terraform plan # show what would change
- terraform apply # create/update/destroy resources to match the config
Terraform is not GCP-specific — the same tool provisions AWS, Azure, and on-premises resources through different provider plugins — which is exactly why it is listed separately from the next tool.
Cloud Foundation Toolkit (CFT) is not a different engine from Terraform — it is Google's own curated library of reusable, opinionated Terraform modules (with some legacy Cloud Deployment Manager templates) that encode Google-recommended patterns: a project-factory module that stamps out new projects with standard IAM bindings and APIs already enabled, a network module that builds a Shared VPC the "right" way, an IAM module, and more. Think of CFT as "pre-built, Google-reviewed Terraform building blocks," not a separate product installed instead of Terraform. A scenario that says "quickly stand up a new project following Google's recommended landing-zone pattern" points to CFT modules; one that says "we need custom, from-scratch infrastructure logic" points to raw Terraform.
Config Connector (Kubernetes Config Connector, or KCC) takes a fundamentally different approach: it is a GKE add-on that lets you manage Google Cloud resources — a Cloud SQL instance, a Cloud Storage bucket, a Pub/Sub topic, even an IAM policy — as native Kubernetes Custom Resources , applied with plain kubectl apply -f against YAML manifests. A controller running in the cluster continuously reconciles the live GCP resource against the desired-state YAML, correcting drift automatically and on an ongoing basis. This is the key architectural distinction from Terraform: Terraform's reconciliation is a point-in-time action (drift is only corrected the next time someone runs terraform apply ), while Config Connector's controller watches and corrects continuously, the same way Kubernetes reconciles a Deployment's replica count. Config Connector is the natural choice for a team that already runs GitOps against a Kubernetes cluster and wants their cloud infrastructure reviewed and managed by the same pipeline and the same kubectl -based tooling as their application manifests.
Helm is the package manager for Kubernetes — conceptually closer to apt or npm than to Terraform or Config Connector. A Helm chart bundles a set of Kubernetes manifests (Deployments, Services, ConfigMaps) together with a values.yaml file of overridable parameters, so the same chart can deploy a "small" version of an app to a dev cluster and a "large, highly-available" version to production by swapping values, not manifests. Helm's job is templating and versioning application deployments onto a cluster that already exists — it does not provision the GCP infrastructure (the VPC, the GKE cluster itself, the IAM roles) around that cluster. That job belongs to Terraform/CFT or Config Connector. The core commands are helm install , helm upgrade , and helm rollback (to a previous release revision).
Comparison Table
Tool What it is Manages Reconciliation model
Terraform General-purpose, multi-cloud declarative IaC engine Any GCP (or other-cloud) resource via provider plugins Point-in-time: only on terraform apply
Cloud Foundation Toolkit Google's library of pre-built Terraform modules Project factory, network, IAM landing-zone patterns Same as Terraform (it is Terraform)
Config Connector GKE add-on managing GCP resources as Kubernetes CRDs Cloud SQL, Storage, Pub/Sub, IAM policy, and more, via YAML Continuous: an in-cluster controller watches and self-heals drift
Helm Kubernetes package manager Application manifests inside an existing cluster N/A — templates and versions releases, not infrastructure
Exam Scenario
A platform team already runs a GitOps pipeline where every change to their GKE cluster's applications flows through pull requests merged into a Git repo, applied by an in-cluster controller. They now want a new Cloud SQL database and a new Pub/Sub topic to be requested and reviewed the exact same way, using the same kubectl -style YAML review process — not a separate Terraform repository. The answer is Config Connector : it lets the Cloud SQL instance and Pub/Sub topic be defined as Kubernetes-native YAML resources, reviewed in the same pull requests, and reconciled by the same in-cluster tooling the team already trusts. A second team that needs to roll out 30 nearly-identical new projects, each with the same IAM bindings, enabled APIs, and Shared VPC attachment, is a Cloud Foundation Toolkit scenario — reusing Google's project-factory Terraform module instead of writing that logic from scratch. A third team deploying the same microservice to five environments with different replica counts and resource limits per environment is a Helm scenario — one chart, five values.yaml overrides.
Key Takeaways
All four tools named on the exam guide — Cloud Foundation Toolkit, Config Connector, Terraform, Helm — are infrastructure-as-code tooling, but each solves a different layer of the problem.
Cloud Foundation Toolkit is a library of Google-curated Terraform modules, not a separate engine from Terraform.
Config Connector manages GCP resources as Kubernetes CRDs with continuous, controller-based drift reconciliation — unlike Terraform's point-in-time apply model.
Helm packages and versions Kubernetes application manifests inside an existing cluster; it does not provision the surrounding GCP infrastructure.
A scenario describing GitOps/ kubectl -driven infrastructure review points to Config Connector; a scenario describing a repeatable multi-project landing zone points to Terraform plus Cloud Foundation Toolkit; a scenario about templated app releases across environments points to Helm.