Prepare and test your skills

Prepare and test your skills

Terraform lifecycle and Fabric FAST deployment describe how to automate Google Cloud infrastructure in a safe and repeatable way. Infrastructure as Code (IaC) (opens in a new tab) defines infrastructure in versioned configuration files instead of manual clicks, so the same configuration can create matching development, test, and production environments. Terraform (opens in a new tab) is the IaC tool that defines Google Cloud resources in human-readable files and moves them through initialization, validation, preview, and apply steps. Infrastructure Manager (Infra Manager) (opens in a new tab) is the managed Google Cloud service that runs those Terraform configurations without requiring a separate automation server.
The Terraform lifecycle through Infrastructure Manager is the ordered path from configuration code to running Google Cloud resources. Infrastructure Manager provides a Google Cloud toolchain for IaC workflows that use Terraform configurations, also called blueprints. Infrastructure Manager does not deploy applications onto resources, so application rollout uses other tools such as Cloud Build or Cloud Deploy.
Infrastructure Manager runs each deployment through an ordered workflow where every step depends on the previous one:
terraform init to initialize providers and modules and terraform validate to check syntax.terraform apply to create resources, and runs terraform destroy when deleting a deployment.After the deployment completes, the Google Cloud resources exist as described by the end-state configuration. The deployment can then be queried for its status, the list of deployed resources, and details about individual resources.
Initialization, planning, and state management control how Terraform prepares, reviews, and tracks infrastructure changes. Initialization with terraform init prepares the working directory by installing providers and modules, while terraform validate checks syntax and preview shows what would change before anything is applied. A GitOps flow with Cloud Build can run terraform plan on feature branches without applying anything, then apply only after code is merged to development or production branches.
Infrastructure Manager manages Terraform state automatically so teams have a central source of truth for each deployment. For each deployment and each revision, Infrastructure Manager stores related records together:
Because Infrastructure Manager handles state, Terraform configurations deployed through it follow specific constraints. Backend blocks should not be defined, templating or generation of Terraform is not supported, and provisioners are not recommended because the runtime environment can change at any time. Configuration values must not include personal or sensitive information, and the configuration must work with a supported Terraform version.
Exam tip: Do not define a backend block when deploying with Infrastructure Manager, because Infrastructure Manager stores the state file for each deployment and revision itself.
Fabric FAST blueprints are standardized Terraform packages for building landing zones and foundations at scale. A Terraform module is a reusable set of configuration files that creates a logical abstraction for one area, such as networking, storage, or identity. A blueprint is a larger package of deployable, reusable modules and policy that implements an opinionated solution, and its deployable configuration is packaged as Terraform modules.
Modules and blueprints differ in scope and reuse:
| Option | What it contains | Use it when |
|---|---|---|
| Module | Reusable configuration files for a logical group of resources | A single capability needs to be reused consistently across environments |
| Blueprint | Deployable modules plus policy and documentation for an opinionated solution | A full landing zone or foundation needs to be deployed the same way every time |
The catalog includes foundations that show this pattern in practice. The fabric collection provides advanced examples designed for prototyping, while the example-foundation blueprint shows how Cloud Foundations Toolkit modules can be composed into a secure cloud foundation. The bootstrap module helps start Terraform usage and related CI/CD in a new Google Cloud organization, so new environments begin from versioned, reviewed, and auditable code.
Config Connector is a Kubernetes extension for Infrastructure as Code (IaC) (opens in a new tab) that manages Google Cloud resources through Kubernetes configuration files. IaC is the process of provisioning and managing infrastructure using code instead of graphical interfaces or manual command-line scripts. Config Connector (opens in a new tab) provides a collection of Kubernetes Custom Resource Definitions (CRDs) where each CRD lets you configure one type of Google Cloud resource from Kubernetes using declarative YAML that can be versioned, reused, and stored in source control.
Each Config Connector resource is a Kubernetes object that creates and manages a matching Google Cloud resource. For example, when you create a Kubernetes object of kind: SQLInstance, Config Connector creates a Cloud SQL instance in Google Cloud. This model lets teams use standard Kubernetes tools, manifests, and continuous integration and continuous deployment (CI/CD) pipelines to manage both cluster workloads and cloud infrastructure. The Kubernetes object remains the single source of truth for the desired configuration of the cloud resource.
Each Config Connector resource separates what you want from what currently exists by using distinct spec and status fields. The spec field holds the desired state that you write, while the status field holds the observed state that Config Connector reports back. When you change a subfield in spec, Config Connector moves the Google Cloud resource toward that value until it is eventually consistent with your intent.
| Field | Purpose | Who writes it | Example |
|---|---|---|---|
spec | Defines the desired state of the Google Cloud resource | You declare it in YAML | databaseVersion in a SQLInstance resource |
status | Reports the current state, readiness, and error messages | Config Connector updates it after reading Google Cloud | connectionName in a SQLInstance resource |
Config Connector periodically reads information from Google Cloud and updates status, so you can check status.condition to see error messages or whether the resource is reconciled and ready. This separation keeps user intent and system feedback in different places, which prevents accidental overwrites of reported state.
Exam tip: spec is writable desired state, while status is read-only observed state; a reconciled and ready resource reports status.condition.status as True.
Object metadata in each Config Connector resource controls how the Kubernetes object maps to its Google Cloud resource. Metadata connects Kubernetes organization concepts to Google Cloud organization concepts, so existing Kubernetes practices for organizing, selecting, and auditing objects apply directly to cloud resources.
spec.resourceID field, you can specify a different Google Cloud name that follows Google Cloud naming rules.managed-by-cnrm with a value of true.spec, such as lifecycle controls. Annotation values must be strings.Name and resourceID preserve the boundary between Kubernetes naming rules and Google Cloud naming rules. Namespace maps the Kubernetes boundary to the Google Cloud project boundary, and labels propagate from Kubernetes to Google Cloud for selection and cost tracking.
The continuous reconciliation loop in Config Connector is the controller process that keeps the actual Google Cloud resource aligned with the declared Kubernetes object. The loop runs in order, and the declared file stays authoritative across development, test, and production environments. History, review, and revert workflows from source control therefore apply to infrastructure changes.

A triangular process flow showing Declare, Actuate, and Observe-and-correct steps between Kubernetes and Google Cloud; an animated dot travels the loop showing drift correction toward spec until eventually consistent.
spec and metadata to the cluster.spec.status, and corrects drift so the live value becomes eventually consistent with spec.This loop provides consistency without manual checks because later observations detect differences and drive the resource back toward the declared state. If someone changes the cloud resource outside Kubernetes, the next observation detects the difference and Config Connector corrects it.
Access control and hierarchical resource support in Config Connector extend Kubernetes-native management to permissions and organization containers. Kubernetes Role Based Access Control (RBAC) secures Config Connector resources by controlling who can create or modify the Kubernetes objects that manage Google Cloud resources. Permission to create a Config Connector object grants the ability to create the corresponding cloud resource, so cluster roles become infrastructure permissions.
In addition to product resources such as databases and storage, Config Connector supports resources in Google Cloud folders and organizations. This support lets one Kubernetes-native workflow manage both workload resources and their hierarchical containers, rather than splitting folder management and resource management into different tools.
Helm packaging and application orchestration is the use of Infrastructure as Code (IaC) (opens in a new tab) to package, version, and deploy Kubernetes applications in a repeatable way. IaC is the process of provisioning and managing infrastructure using code instead of graphical interfaces or manual scripts, and Helm applies that same idea to applications running on Kubernetes such as Google Kubernetes Engine (GKE) (opens in a new tab). A team defines the desired state of the application once, stores that definition in source control, and deploys the same package multiple times to create reproducible development, test, and production environments.
A Helm chart is a versioned package that bundles all of the Kubernetes resources needed for an application into one reusable unit. The chart declares the desired state of the application, so Helm and Kubernetes work to make the live environment match that declared state. Because charts can be versioned, reused, and shared, teams can keep a history of changes, audit what changed, and revert to an earlier version when needed. This versioning makes the chart a single source of truth for how the application should be deployed.
Templates and values files in Helm separate the reusable structure of an application from the settings that change between environments. Templates define the common Kubernetes manifests with placeholders for image names, replica counts, resource limits, and connection settings, while a values file supplies the actual values that fill those placeholders at deploy time. Data flows from the values file into the templates, and Helm renders the templates into the final manifests that are applied to the cluster. To support multiple environments, a team keeps one shared chart and maintains a different values file for development, test, and production, so only the values change while the chart structure stays consistent.
IaC benefits applied to Helm deployments come from treating charts and values files like application code. Configuration is stored in source control and managed through continuous integration and continuous deployment (CI/CD) pipelines, where changes can be reviewed and automatically validated before reaching production. These practices reduce manual effort and error, which is especially important when managing applications at scale across many clusters and environments.
Helm in the Google Cloud IaC toolchain fills the application layer, while Terraform-based tools provision the underlying Google Cloud infrastructure. HashiCorp Terraform uses human-readable configuration files to define Google Cloud resources such as virtual machines, networks, storage, and GKE clusters throughout their lifecycle. Infrastructure Manager (Infra Manager) automates the deployment and management of those Terraform configurations directly on Google Cloud without maintaining a separate toolchain.
| Tool | What it manages | Choose when |
|---|---|---|
| HashiCorp Terraform | Google Cloud infrastructure including VMs, networks, storage, and GKE clusters | The need is to provision and manage platform resources with versioned, reusable configuration |
| Infrastructure Manager (Infra Manager) | Deployment of Terraform configurations on Google Cloud | The need is to deploy Terraform programmatically using a Google Cloud service |
| Helm | Kubernetes applications packaged as charts with templates and values files | The need is to package, version, and deploy workloads inside a Kubernetes cluster across environments |
Use Terraform to create the cluster and Helm to deploy applications onto it, so platform provisioning and application orchestration stay in separate, reusable layers. This separation lets infrastructure teams and application teams work from their own versioned packages while sharing the same review and pipeline practices.
Exam tip: Choose Terraform and Infrastructure Manager for Google Cloud platform resources, and choose Helm when the task is deploying and configuring a Kubernetes application from a chart with different values per environment.
terraform init, preview or apply with terraform apply, and stores logs, configuration, resource lists, and state per deployment revision.spec for desired state written by the user and status for observed state reported by the controller, with Kubernetes namespace mapping to the Google Cloud project.spec and corrects drift to keep them eventually consistent.Infrastructure Manager (Infra Manager) runs Terraform configurations through an ordered workflow where each step depends on the previous one. You define a declarative configuration with a Terraform root module, store it in a Cloud Storage bucket, Git repository or local directory, have Infrastructure Manager validate the request and run an automated Cloud Build job to initialize providers and modules, validate syntax and preview or apply changes, and then have logs and deployment metadata stored for later queries.
You should not define a backend block because Infrastructure Manager (Infra Manager) stores the Terraform state file itself for each deployment and revision. Infrastructure Manager also stores the related logs, configuration and resource lists together to provide a central source of truth, so defining your own backend would conflict with that managed state handling.
Config Connector keeps Google Cloud resources aligned through a continuous reconciliation loop where you declare desired state in the spec field and Config Connector creates or updates the resource toward that value. Config Connector periodically reads the live Google Cloud resource, reports observed state and readiness in the status field, and corrects drift so the live value becomes eventually consistent with spec.
Use HashiCorp Terraform and Infrastructure Manager (Infra Manager) to provision and manage Google Cloud platform resources such as virtual machines, networks, storage and Google Kubernetes Engine (GKE) clusters, and use Helm to package, version and deploy Kubernetes applications inside the cluster. Helm uses one shared chart with templates for the reusable structure and separate values files for development, test and production, so platform provisioning and application orchestration stay in separate reusable layers.
Your platform engineering team is adopting Terraform to provision and manage Google Cloud foundation resources across multiple project environments. Currently, individual team members run Terraform locally, which causes state synchronization conflicts and increases the risk of corrupted resource mappings.
You need to establish a collaborative Terraform lifecycle workflow that centralizes state storage, prevents concurrent modification issues, and retains a history of deployments according to Google Cloud best practices.
Which configuration should you implement?
Last updated