Study guide
2.2 Organization Policies & Granting IAM Roles
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
2.2 Organization Policies & Granting IAM Roles
Key Takeaways Explain This Topic AI
IAM controls who can do what (identity-based allow policies); Organization Policy Service controls what configurations are allowed at all, regardless of identity
Organization policies inherit down the hierarchy by default, and a child node either takes the parent value as-is or fully overrides it - values are never merged
Setting org policies requires the Organization Policy Administrator role (roles/orgpolicy.policyAdmin); granting IAM roles requires resourcemanager.projects.setIamPolicy or the folder/organization equivalent
gcloud projects add-iam-policy-binding / remove-iam-policy-binding change a single binding safely; set-iam-policy replaces the whole policy and is reserved for bulk edits
Basic roles (Owner, Editor, Viewer) carry thousands of permissions each and are almost always the wrong answer on a least-privilege exam question
Last updated: July 2026
Why This Topic Matters
Domain 1 of the exam guide pairs two closely related but frequently confused controls: applying organizational policies to the resource hierarchy and granting members IAM roles within a project . Exam writers love scenarios that require you to pick the right tool — Organization Policy Service or IAM — because using the wrong one either doesn't work or is far more brittle to maintain. Get this distinction wrong on the exam and you'll misdiagnose half the "why can't this resource be created" scenario questions.
Quick Answer: IAM answers " who can do what " — it grants roles (bundles of permissions) to principals (users, groups, service accounts, domains) on a resource. Organization Policy Service answers " what configurations are allowed at all , regardless of who is asking" — it restricts things like external IPs on VMs or which regions resources can be created in, and it applies even to project Owners.
Organization Policies: Constraints, Not Permissions
An organization policy is built from a constraint — a predefined restriction you can enforce on a node in the resource hierarchy. Google Cloud has three constraint categories:
- Constraint Type Who Defines It Example
- Managed constraint Google constraints/compute.vmExternalIpAccess — restrict which VMs can have external IPs
Custom constraint Your organization (via CEL expressions) Require all new Compute Engine instances to use a specific machine family
Legacy constraint Google (older list/boolean style) constraints/iam.disableServiceAccountKeyCreation
Constraints come in two shapes:
Boolean constraints — simple on/off enforcement (e.g., disable serial port access entirely).
List constraints — allow or deny specific values, using hierarchy-aware prefixes like under: (include an entire subtree) or in: (match a specific value or group), e.g. restricting constraints/gcp.resourceLocations to in:us-locations .
Inheritance Rule (frequently tested)
When you set an organization policy on a node, every descendant folder and project inherits it by default . Critically, inherited managed-constraint values are not merged with a child's own policy — a child either takes the parent's policy as-is, or fully overrides it with its own configuration for that constraint. This is different from IAM, where permissions genuinely accumulate down the tree. Setting or changing org policies requires the Organization Policy Administrator role ( roles/orgpolicy.policyAdmin ).
Common Constraints to Know
constraints/compute.vmExternalIpAccess — block VMs from getting public IPs org-wide.
constraints/gcp.resourceLocations — restrict which regions/zones new resources can be created in (data residency).
constraints/iam.allowedPolicyMemberDomains — Domain Restricted Sharing , preventing IAM grants to identities outside approved domains (stops someone from adding a personal Gmail account as a project Viewer).
Granting IAM Roles Within a Project
Once you know whether a rule belongs in org policy vs. IAM, granting the actual roles is straightforward. IAM roles bind to a principal — user:name@example.com , group:team@example.com , serviceAccount:sa-name@project.iam.gserviceaccount.com , or domain:example.com — and to a role on a resource (organization, folder, or project).
Basic (Legacy) Roles — Know Them, Avoid Them in Production
- Role Grants
- roles/viewer Read-only access to almost everything
- roles/editor Viewer + create/modify most resources
- roles/owner Editor + manage IAM roles and billing
These basic roles carry thousands of permissions across every Google Cloud service and are a common exam trap: a scenario describing "over-permissioned" access, or asking for the least-privilege fix, is almost always steering you away from Editor/Owner and toward a scoped predefined or custom role (the full predefined/custom role taxonomy is covered in Chapter 14).
- Granting a Role with gcloud gcloud projects add-iam-policy-binding retail-data-prod \
- -member="group:data-analysts@example.com" \
- -role="roles/storage.objectViewer"
add-iam-policy-binding appends one binding without disturbing any existing ones — the safe, everyday command. Its counterpart, remove-iam-policy-binding , revokes a single binding the same way. For bulk edits, use the read-modify-write pattern : gcloud projects get-iam-policy PROJECT_ID --format=json > policy.json , edit the file, then gcloud projects set-iam-policy PROJECT_ID policy.json — but this replaces the entire policy , so it's riskier for a single-binding change than add-iam-policy-binding .
Granting or revoking roles yourself requires resourcemanager.projects.setIamPolicy (or the folder/organization equivalent), which is bundled into roles like Project IAM Admin , Folder Admin , and Organization Administrator — you do not need the basic Owner role just to manage access.
Console Path
IAM & Admin → IAM → Grant Access → enter the principal → search for and select one or more roles (searchable by name, product, or job function) → optionally attach an IAM Condition (e.g., time-bound access) → Save .
Exam Scenario
A security team wants to guarantee that no user, service account, or future automation — no matter what IAM role it holds — can ever launch a Compute Engine VM with a public IP address, across every project in the company. Granting a narrower IAM role won't achieve this, because IAM only controls who has which permissions; it can't structurally forbid a resource shape for everyone including Owners. The correct fix is an organization policy using constraints/compute.vmExternalIpAccess applied at the organization node, so it cascades to every folder and project beneath it regardless of any individual's IAM grants.
Takeaways for the Exam
IAM = who can do what (identity-based, additive allow policies). Organization Policy = what configurations are allowed (resource-based, applies to everyone including Owners).
Org policies cascade down the hierarchy; a child either inherits the parent's value as-is or fully overrides it — values are never merged.
add-iam-policy-binding / remove-iam-policy-binding are the safe, single-change commands; set-iam-policy replaces the whole policy and is reserved for bulk edits.
Avoid granting basic roles (Owner/Editor/Viewer) in production scenarios on the exam — they are the "wrong answer" whenever a question asks for least privilege.