Prepare and test your skills
Prepare and test your skills
Resource hierarchy and boundary enforcement is the use of Google Cloud organization, folder, and project structure with policy controls to keep security duties separate from development work. Projects sit inside folders inside an organization, and boundaries are enforced where folders and projects meet with organization policies, Identity and Access Management (IAM) (opens in a new tab) policies, and service perimeters. Security teams manage guardrails at the organization and folder levels while developers manage resources inside assigned application projects, so elevated access in one project does not grant access to keys, data, or controls in another boundary.
A functional resource hierarchy separates workloads by purpose so each team receives only the access it needs. A common production pattern places application folders and projects inside a Prod folder and places a dedicated key project inside a Shared folder where the Cloud Key Management Service (Cloud KMS) (opens in a new tab) API is enabled. Developers can hold the Project Owner role inside an individual application project without receiving privileges on the key project, so resource management stays separate from key custody. The same separation applies to data, where one project holds replicated raw data for technical users and a second project holds reporting models and views for business users, which prevents business users from gaining excessive access to raw data.
VPC Service Controls (opens in a new tab) is the service that creates a data-exfiltration boundary around Google Cloud projects and protected APIs. A single large boundary, called a common unified perimeter, provides the most effective protection with the lowest management overhead because services and network resources inside the perimeter can communicate freely once IAM and network controls permit them. The perimeter management team then focuses mainly on north-south access, which is access from the internet to resources inside the perimeter, rather than east-west traffic between perimeters. Boundaries should be layered with blocking direct internet egress from VPC networks, enabling all protected services to reduce exfiltration vectors, and continuing to apply IAM least privilege because service perimeters do not replace IAM controls.
Multiple perimeters are separate VPC Service Controls boundaries inside one organization that isolate data with different trust, compliance, or sharing needs. Data flows freely inside each perimeter, but movement between perimeters is treated as a controlled crossing that the perimeter team must manage, so multiple perimeters add east-west management overhead in addition to north-south control.
Choose multiple perimeters only when one of these isolation needs outweighs the added cost, and keep the design simple by avoiding multiple bridges, perimeter network projects, DMZ perimeters, and complex access levels.
Key storage models define where Cloud KMS keys live relative to the data they protect, and the choice determines how project boundaries enforce separation of duties. Dedicated-project storage centralizes keys in a shared key project, while same-project storage co-locates each key with the resources it protects so the key follows the data. Central security teams set organization-level and folder-level guardrails in both models, but ownership and operational tradeoffs differ by model.
| Storage model | Where keys live | Choose when |
|---|---|---|
| Dedicated-project key storage | All keys for an environment folder live in a centralized key project inside a Shared folder; application projects hold Compute Engine instances and Cloud Storage buckets but hold no keys | Strict central control is required, such as PCI DSS or BSI C5 need for a Cryptographic Officer, external HSM use, or a small audited group of Cloud KMS Admin holders |
| Same-project key storage | Each key lives in the same project as the Compute Engine instances, Cloud Storage buckets, or other resources it protects | Developer velocity, agility, and clear accountability matter most and key ownership should align with data ownership through delegated management |
Dedicated-project storage lets developers keep elevated privileges in application projects without key-project access, but it creates cross-project IAM complexity that often needs a Project Factory or Cloud KMS Autokey (opens in a new tab) to avoid bottlenecks. Same-project storage simplifies setup and delegation, but without Autokey developers need elevated Cloud KMS privileges in the resource project and separation depends on diligent auditing. Use the same storage pattern across development, testing, and production for a given application so IAM permissions and pipelines are tested before production and configuration drift does not cause deployment failures.
Role separation in Cloud KMS requires a strict distinction between key managers who govern key lifecycles and key users who perform encryption and decryption. No human developer needs direct cryptographic use permissions for customer-managed encryption keys (CMEK) integrations because the Google service agent performs encryption and decryption on behalf of the resource. Guardrails at the organization and folder levels enforce this boundary through organization policy constraints, IAM grants, IAM deny policies, and regular audits for excessive privilege.
roles/cloudkms.admin) to create, rotate, enable, disable, destroy, and set IAM policies on keys, and this responsibility belongs to human administrators and privileged infrastructure-as-code (IaC) principals.roles/bigquery.user) or Compute Admin (roles/compute.admin) to select an existing key during resource creation, and this responsibility belongs to developers and IaC pipelines without elevated key privileges.roles/cloudkms.cryptoKeyEncrypterDecrypter) to encrypt and decrypt data with the key, and this permission is granted only to service agents and is granted automatically when Autokey is used.In same-project storage, IAM deny policies remove encryption and decryption permissions from key managers to preserve separation inside one project. In dedicated-project storage, the central security team holds key administration in the key project but is restricted from the application projects that hold the protected resources. Audit regularly so combinations of roles across projects do not create escalation or exfiltration paths, and restrict powerful roles such as Project IAM Admin to trusted leads.
Exam tip: No principal should hold both Cloud KMS Admin and Cloud KMS CryptoKey Encrypter/Decrypter on the same key, including a Project Owner.
Automated boundary compliance uses Google Cloud tools that preserve separation of duties without giving developers or pipelines standing elevated access. Cloud KMS Autokey supports both dedicated-project and same-project storage and grants the key usage role to the required service agent rather than to the person requesting the key, which supports IaC pipelines without elevated key creation privileges.
Together these controls keep the hierarchy enforceable over time because automation prevents manual privilege grants, detection surfaces combined admin-plus-use access, and metrics confirm that resources remain protected by the intended boundary.
Identity and Access Management (IAM) (opens in a new tab) role granularity and administrative isolation is the practice of splitting powerful administrative duties from day-to-day operational work so no single identity controls too much. Granularity means granting only the smallest role at the smallest scope needed for a task, and isolation means limiting who holds organization-wide power such as Google Workspace super admin. When administrative functions are isolated this way, a compromised or misused account cannot easily move from one system to take over another.
Least privilege in IAM means granting a user only the roles required to accomplish a specific task at the smallest resource scope. A developer who needs to view virtual machines should not also receive permission to change IAM policy or delete projects, because that extra access increases blast radius if developer credentials (opens in a new tab) are stolen. To keep policies tight over time, teams should review and apply role recommendations (opens in a new tab) that flag unused and excessive roles in the environment.
A Google Workspace super admin holds implicit full control over the linked Google Cloud organization. A super admin can modify the IAM policy of the organization node and assign themselves the organization administrator role or any other role in the organization. That same privilege also allows the user to delete the Cloud Identity (opens in a new tab) or Google Workspace account, its associated Google Cloud organization, and all of its resources. You must therefore assume that super admins have full access to all resources within an organization, even if they were only intended to manage email or users.
Segregating Workspace and Cloud administration means reducing the number of super admins rather than trying to split Google Workspace and Google Cloud into fully separate accounts. Creating a separate Cloud Identity account to block Workspace super admins creates duplicate users, higher administrative overhead, and broken notification email routing. Referencing Workspace users from the Cloud organization also fails as isolation, because a Workspace super admin can use domain-wide delegation to impersonate any user in the same Workspace account and regain access to Google Cloud.
A more effective approach keeps one identity system and isolates duties with granular roles:
This distribution keeps operational Workspace work separate from organization-wide Cloud control, so a single compromised help-desk or user-management account does not become an organization takeover.
Administrative isolation in Google Cloud extends beyond IAM roles to the external systems that Cloud Identity and Google Workspace depend on. When single sign-on is enabled, Cloud Identity trusts an external identity provider (IdP) (opens in a new tab) to authenticate users through a signed SAML assertion, but Google cannot verify that the IdP made the correct authentication decision. The security of the IdP itself, the machines it runs on, the user database it reads from, and any other system it depends on therefore directly determines the security of Google Cloud access. Limit administrative access to the IdP and its dependencies, and do not grant IdP administration to anyone you would not also trust with super admin privilege.
The same boundary applies to DNS zones for the primary domain used by Cloud Identity or Google Workspace. Google Workspace relies on DNS MX records for email routing, and an attacker who can add records to the DNS zone may be able to reset a super admin password and take over the account. DNS administration therefore sits inside the same trust boundary as super admin, so access to the DNS server that manages the primary domain must be limited to the same small group. Security and incident response teams still need appropriate access across both the Google Cloud console and the Admin console in advance, so they can investigate without being granted standing excessive control.
Exam tip: Do not try to isolate Google Cloud by creating a separate Cloud Identity account; reduce super admins with granular Workspace roles instead, because a Workspace super admin can regain Cloud access through domain-wide delegation.
Auditing, monitoring, and multi-party authorization verify that administrative actions in Google Cloud follow separation of duties. Cloud Audit Logs (opens in a new tab) record who performed which action and when, monitoring detects unusual privileged use, and multi-party workflows require independent validation before sensitive changes take effect. Together they ensure no single administrator can make critical changes without review.
Cloud Audit Logs are the record of administrative activity that proves separation of duties is working. Administrators enable audit logging for services such as the Compute Engine API by adding an auditConfigs section with ADMIN_READ, DATA_READ, and DATA_WRITE log types, and they export those logs to BigQuery to persist them for audit and analysis. Teams then review privileged access requests and access patterns in the logs to detect anomalies and suspicious activity among highly privileged users.
Critical audit events that support this review include:
Because Privileged Access Manager (opens in a new tab) also writes audit logs that track who had access to which resources and when, reviewers can link an approved elevation to the actions that were actually performed.
Monitoring of privileged use focuses on temporary elevation and breakglass accounts that hold highly privileged Identity and Access Management (IAM) roles. Breakglass access is last-resort access used when normal automation breaks down, and its scope should be designed so different business units cannot disrupt each other. Monitoring must create an alert when a predefined breakglass account is used, for example by configuring a custom Event Threat Detection (opens in a new tab) module to create a security finding.
Different breakglass purposes require different scopes and controls:
| Breakglass purpose | Description |
|---|---|
| Super admin | Emergency access to the super admin role in Cloud Identity to fix identity federation or multi-factor authentication issues |
| Organization administrator | Emergency access to the Organization Administrator role, which can then grant any other IAM role in the organization |
| Foundation pipeline administrator | Emergency access to modify resources in the CI/CD project and external Git repository when pipeline automation breaks down |
| Operations or SRE | Privileged access for operations teams to respond to outages, such as restarting VMs or restoring data |
Privileged access should either expire automatically or be reviewed periodically. Extra protection comes from requiring 2-step verification for all privileged users (opens in a new tab) and from Access Context Manager (opens in a new tab), which can require attributes such as being on the corporate network when privileged access is used.
Privileged Access Manager is the service for just-in-time, temporary privilege elevation with independent approval. Instead of granting standing admin rights, an administrator defines an entitlement and mandates multi-level and multi-party approvals, with up to two levels of sequential approvals for each entitlement. Abuse is prevented by requiring approvals and by split operations, where one person holds credentials and a different person holds the multi-factor authentication token.
A typical separation-of-duties workflow moves access from request to audited use in order:
elevated-compute-access.roles/iam.serviceAccountTokenCreator and roles/serviceusage.serviceUsageConsumer, which let the group impersonate a service account that holds a privileged role such as roles/compute.admin.Exam tip: Audit logs verify what happened after the fact, while multi-party approvals must complete before temporary access is granted — up to two sequential approval levels can be required for one entitlement.
Dedicated-project key storage centralizes all keys for an environment in a shared key project inside a Shared folder while application projects hold resources but no keys, whereas same-project key storage places each key in the same project as the resources it protects. Choose dedicated-project storage when strict central control is required such as for PCI DSS or external HSM use, and choose same-project storage when developer velocity, agility and delegated management matter most.
A single common unified perimeter provides the most effective protection with the lowest management overhead because services and network resources inside the perimeter can communicate freely once Identity and Access Management (IAM) and network controls permit them. Use multiple perimeters only when isolation needs outweigh the added east-west management overhead, such as separating high-trust data from de-identified data, isolating regulated data for PCI DSS, sharing data products with outside entities, or isolating independent third-party tenants where cross-tenant movement is considered exfiltration.
No principal should hold both administrative and cryptographic use permissions on the same key because role separation requires key managers who govern key lifecycles to be distinct from key users who encrypt and decrypt. For customer-managed encryption keys (CMEK) integrations, only service agents should hold cryptographic use and they perform encryption and decryption on behalf of the resource, while key administration belongs to human administrators and privileged infrastructure-as-code principals.
Privileged Access Manager provides just-in-time temporary privilege elevation with independent approval and up to two sequential approval levels before access is granted. Approved users impersonate a privileged service account and all actions flow to Cloud Audit Logs for review, and membership expires automatically so normal operations resume without manual cleanup.
An enterprise organization is structuring its Google Cloud resource hierarchy to maintain a strict separation of duties across departments. The company must satisfy the following security and governance requirements:
Which resource hierarchy and access management architecture should the organization implement?
Last updated