Prepare and test your skills
Prepare and test your skills
Governance through private catalogs is the practice of publishing only approved cloud solutions for teams to discover and launch. Service Catalog (opens in a new tab) is the Google Cloud governance service that provides this control under a Google Cloud organization. A cloud admin creates a catalog, fills it with curated solutions, and shares it with selected folders or projects so users deploy compliant resources instead of unapproved infrastructure.
What Service Catalog controls is which solutions are trustworthy, who can see them, and under what guardrails they can launch. The catalog acts as a single point of entry for both admins and users, replacing ad hoc distribution like emails and wikis with a central place that can be curated and updated. Because Service Catalog respects organization policies and Cloud Deployment Manager (Deployment Manager) constraints, those broader controls continue to apply to every launch from the catalog.
Service Catalog provides the building blocks for this model:
The relationship is hierarchical: the organization holds the catalog, the catalog holds the solutions, and sharing grants visibility from the catalog down to users in specific folders and projects.
Hierarchy from organization to catalog to solutions, showing how sharing a catalog grants visibility to users in specific folders and projects.
Curated solutions in Service Catalog are the approved items that users discover and deploy from a shared catalog. Cloud admins manage their solutions centrally and update the content over time, which ensures users always launch the latest versions rather than stale or unpatched images. Curation therefore solves both consistency and freshness, because the admin updates the solution once and every authorized user sees the same current version.
Service Catalog supports two solution types that cover deployable infrastructure and approved information:
| Solution type | What it contains | Governance use |
|---|---|---|
| Deployment Manager template | Reusable infrastructure template plus a schema file that can limit region and machine type | Enforce where a solution can deploy and control cost and compliance at launch time |
| Reference link | Verified web link, such as help documentation or an approved external resource | Distribute only admin-reviewed links instead of unvetted sources |
A Deployment Manager template flows from the admin to the user to the deployment target, with the schema constraining the launch before resources are created. For example, an admin can define the allowed region and machine type so the team stays within budget while still self-serving the deployment.
Catalog creation in Service Catalog is a controlled admin workflow that requires the right organization scope and role. Before starting, Service Catalog must be enabled for the Google Cloud organization, and the creator must hold the Catalog Admin role (roles/cloudprivatecatalogproducer.admin) on that organization. If the role is missing, access must be requested from the Organization Administrator.
To create a catalog (opens in a new tab) in the Google Cloud console, follow this ordered workflow:
After creation, the next governance steps are to assign solutions to the catalog and then share the catalog with specific folders or projects. Sharing restricts distribution by boundary, because only users in the shared scope with permission can see the catalog and its solutions.
Exam tip: A catalog name cannot be changed after creation, while the catalog description is visible only to Service Catalog admins.
How catalogs enforce compliance in practice is by combining curation, restricted sharing, and existing policy controls. The admin curates which solutions are trustworthy, sharing limits which teams can discover them, and organization policies plus Deployment Manager constraints limit how they can be configured at launch. This layered approach lets admins permit self-service without permitting arbitrary launches.
A typical outcome is cost and license control: an admin publishes a known, free virtual image as the approved solution so engineers use it instead of launching unauthorized paid software. Unauthorized instances and surprising charges drop because the easy, discoverable path is also the compliant path, while policy controls remain as defense in depth behind the catalog.
Secure self-service provisioning in Google Cloud lets teams request and receive resources quickly without bypassing governance. The model combines a standard resource hierarchy for placement, billing, and inheritance, Identity and Access Management (IAM) for least-privilege access, and a defined lifecycle from request through optimization to decommissioning. When these parts work together, central teams control guardrails while workload teams deploy at scale.
The Google Cloud resource hierarchy (opens in a new tab) is the structure that determines visibility, billing, and security inheritance for every self-service request. The Organization resource sits at the apex and provides central visibility and control over everything below it, folders group related projects, and projects hold service resources such as Compute Engine virtual machines (VMs), Pub/Sub topics, Cloud Storage buckets, and Cloud VPN endpoints. An IAM allow policy attached at the organization or folder level flows down to child projects and resources, so placement in the hierarchy directly decides which guardrails apply.
Resources can be created through the Google Cloud console, Cloud Shell, or Cloud APIs, and existing test projects can be migrated into the organization to bring them under the same controls. If the environment changes frequently, an infrastructure as code (IaC) approach with tools such as Terraform, Deployment Manager, or automated provisioning systems makes deployment consistent and repeatable. Consistent folder and project structure plus consistent labels are required for tracking ownership, cost, and compliance, because inconsistent naming forces manual cleanup that does not scale.
Identity and Access Management (IAM) is the system that grants granular access to Google Cloud resources. Cloud Identity is the identity as a service (IDaaS) platform that centrally manages users and groups and enables single sign-on (SSO) to third-party applications. No member or workload can access resources without an identity that Google Cloud understands, so onboarding identities is the prerequisite for any self-service catalog.
The access model consists of four connected concepts:
Access is managed at scale by placing users in groups managed by the existing identity provider, synchronizing those groups with Cloud Identity, and then granting IAM roles to the groups under the principle of least privilege. Identity federation can be delivered through two patterns that differ by source of identities and compliance fit:
| Option | Use when | How access is granted |
|---|---|---|
| Google Cloud Identity | The organization uses Google Workspace or syncs identities from its identity provider (IdP) to Google Cloud | Create managed user accounts and define IAM policies with predefined or custom roles for users and groups |
| Workforce Identity Federation | The organization uses a third-party IdP such as Okta or Microsoft Entra ID (Azure AD) | Create a workforce identity pool to grant on-premises or multi-cloud users access without using service account keys |
Granting roles to synced Google Groups at the folder or project level avoids reworking every binding when people join, move, or leave, which is why group-based grants preserve least privilege at scale.
Exam tip: Grant IAM roles to synced Google Groups at the folder or project level, not to individual user accounts, to enforce least privilege and avoid reworking every binding when people join, move, or leave.
A standardized provisioning workflow is the ordered path that turns a team request into a governed, billable project ready for workloads. The workflow depends on the resource hierarchy for placement, depends on IAM for initial access, and depends on networking and billing controls to prevent insecure or untracked deployments. Central teams define the catalog of approved choices once, and self-service requests then select from those choices instead of creating ad hoc configurations.
A complete lifecycle moves through ordered states:
Every new workload project created through automation, such as a project factory, should set the same attributes:
These attributes connect placement, identity, networking, and billing in one repeatable creation event, so later audits can trace every project to its owner and cost center.
Quotas, optimization, and ongoing governance determine whether self-service remains fast, affordable, and secure after provisioning. Project quotas limit the ability to create resources in the cloud, so catalog design must account for quota availability and request increases before teams hit failures. Budgets and billing alerts tied to each project connect consumption back to the requesting team, and labels allow billing reports and BigQuery export to be filtered for finer visibility than default reports provide.
Ongoing optimization keeps active resources right-sized as demand changes. Cloud Monitoring provides real-time visibility into utilization, Recommender analyzes that data to suggest smaller machine types or cleanup actions, and custom metrics with alerts can trigger timely resizing by administrators. Compute Engine managed instance groups (MIGs) support autoscaling policies with minimum and maximum VM counts that add capacity when CPU utilization rises and remove it when utilization falls, which avoids both over-provisioning costs and under-provisioning bottlenecks. The Active Assist portfolio extends the same review pattern to security posture, including firewall insights and IAM recommender findings for over-privileged roles.
Governance at scale requires coordination between central and workload teams and a clear path for exceptions. Workload teams create firewall needs through tags, the networking team owns the network firewall policy and delegates tag-use IAM roles, so traffic flows only between approved tagged resources without giving every team network-wide edit rights. Organization policy constraints apply broadly by default, such as iam.disableServiceAccountKeyCreation to block risky key creation, with limited exceptions granted only for justified use cases that adopt more secure authentication alternatives.
Automated provisioning and infrastructure as code (IaC) is the practice of defining Google Cloud resources in version-controlled configuration files and letting automation create and update them. The configuration describes the desired state, and the provisioning tool calls Google Cloud APIs to make real infrastructure match that state. This approach removes manual clicks, makes deployments repeatable across development and production, and lets governance rules travel with the code.
How Terraform provisions Google Cloud resources is through a declarative workflow that maps configuration files to real infrastructure. HashiCorp Terraform (opens in a new tab) is a declarative IaC tool that provisions and manages cloud infrastructure without requiring code for each API call. Terraform uses plugins called providers, including the Google Cloud Terraform Provider, to interact with Google Cloud APIs and services such as Google SecOps.
The provisioning workflow moves from configuration to real infrastructure in an ordered sequence:
terraform plan, which evaluates the configuration and generates an execution plan for review before anything changes.terraform apply, which invokes the corresponding Google Cloud APIs in the background to create or update infrastructure and writes a Terraform state file.The Terraform state file is a JSON file that maps resources in the configuration file to resources in real-world infrastructure. On each terraform apply, Terraform compares existing infrastructure to the code using the mapping in the state file. If a resource is defined in the configuration but missing from the state file, Terraform creates it; if a resource in the state file has a different configuration than the configuration file, Terraform updates it to match; if the state file matches the configuration file, Terraform leaves the resource unchanged.
Standardized starting points for Terraform on Google Cloud are four layered approaches that range from raw building blocks to opinionated landing zones. Choosing a starting point controls how much governance, structure, and reuse you inherit versus how much you build yourself. All four approaches build on the Google Cloud Terraform Provider, with each higher layer adding more opinionated defaults.
| Approach | Start when | Builds on |
|---|---|---|
| Resources in the Google Cloud Terraform Provider | You want to start from scratch using base building blocks | Provider resources directly |
| Terraform blueprints and modules for Google Cloud | You want a baseline of opinionated, reusable modules | Resources in the Google Cloud Terraform Provider |
| Enterprise Foundations Blueprint | You want an opinionated foundation and landing zones with security defaults | Terraform blueprints and modules for Google Cloud |
| Cloud Foundation Fabric | You want an opinionated foundation and landing zones as a standalone implementation with its own modules | Resources in the Google Cloud Terraform Provider |
A foundation built this way provisions the shared infrastructure that supports workloads and migration, including resource hierarchy, Identity and Access Management (IAM), billing, network connectivity, security hardening, and logging, monitoring, and alerting. Because the foundation itself is code, new workload projects can be created through the same pipeline with consistent attributes such as enabled APIs, Shared VPC attachment, IAM roles, labels, folder placement, billing account, and budget alerts.
Maintaining consistency across development and production means organizing Terraform configurations as modular, version-controlled templates and promoting the same artifacts through automated pipelines. Cluster Toolkit provides Google-curated Terraform blueprints for deploying ready-to-use high-performance computing (HPC), artificial intelligence (AI), and machine learning (ML) clusters on Slurm or Google Kubernetes Engine (GKE), which teams can customize and store in version control. Config Connector extends the same declarative model into Kubernetes by managing Google Cloud resources as Kubernetes objects using YAML manifests applied to a GKE cluster.
Common infrastructure managed this way includes:
Infrastructure Manager and Cloud Build integrate IaC into continuous integration and continuous deployment (CI/CD) pipelines to automate the full resource lifecycle. A commit triggers automated testing and validation, such as running Terraform validate and plan, and configurations are stored as versioned artifacts with separate dev, staging, and prod definitions. Immutable infrastructure strengthens this model by requiring that resources are never modified after deployment; an update is made in the source repository, tested, and then fully redeployed, which prevents configuration drift and snowflake servers.
Governance best practices for automated provisioning prevent automation from creating inconsistency, privilege sprawl, or untracked changes. Baking virtual machine images with a tool like Packer lets Terraform launch machines from pre-baked images instead of configuring each machine at creation time. If pre-baked images are unavailable, Terraform can hand off a new virtual machine to configuration management with a provisioner block, but provisioners are a last resort, VM configuration should be passed through instance metadata, and teardown logic should use when = destroy.
IAM provisioning requires choosing non-authoritative controls so Terraform does not overwrite permissions it does not own. The google_*_iam_policy and google_*_iam_binding resources create authoritative associations where Terraform becomes the only source of truth and overwrites all permissions on the next run, which can remove Google-managed roles and break services. The google_*_iam_member resource and the Google IAM module add individual members without claiming the full policy, which preserves permissions managed outside that configuration. Consistent labeling and folder and project structure complete the governance model by giving cost, compliance, and asset inventory systems a reliable way to identify resources.
Exam tip: Use google_*_iam_member for additive IAM changes; google_*_iam_policy and google_*_iam_binding are authoritative and overwrite the full policy on the next apply.
Service Catalog is the Google Cloud governance service that publishes only approved cloud solutions for teams to discover and launch. The organization holds the catalog, the catalog holds curated solutions, and sharing the catalog with selected folders or projects grants visibility so users deploy compliant resources, while organization policies and Cloud Deployment Manager (Deployment Manager) constraints continue to apply to every launch.
Service Catalog supports Cloud Deployment Manager (Deployment Manager) templates and reference links. A Deployment Manager template contains a reusable infrastructure template plus a schema file that can limit region and machine type to enforce cost and compliance at launch time, while a reference link distributes a verified web link such as help documentation or an approved external resource instead of unvetted sources.
HashiCorp Terraform provisions Google Cloud resources through a declarative workflow that uses the Google Cloud Terraform Provider to interact with Google Cloud APIs. You write resource blocks declaring the desired state, run terraform plan to preview changes, then run terraform apply to create or update infrastructure and write a JSON state file that maps configuration resources to real infrastructure.
An enterprise organization is establishing a standardized self-service provisioning and access management workflow for engineering teams in Google Cloud. The cloud architecture team must implement an access lifecycle model that meets the following security and governance requirements:
roles/editor upon creation.Which combination of IAM and governance controls should you implement?
Last updated