SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
ACE · Domain 4

Configuring access and security practice questions

Configuring access and security is worth 20% of the ACE exam — the 3rd-heaviest of the 4 domains. Managing IAM policies and roles, and service accounts, on Google Cloud. Official (approximate) weighting ~20%. 6 fully worked examples are further down this page, answers included.

Exam weight
20%
the 3rd-heaviest of the 4 domains
Questions
88
across 2 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 4 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Configuring access and security questions, fully explained

Questions from the ACE bank mapped to domain 4, with the answer key and the reasoning behind every option. None of them repeat the examples on the main ACE practice page.

Question 1Configuring access and security

A new operations engineer must be able to start, stop, and reconfigure Compute Engine VM instances in a production project. They must not be able to change VPC networks, firewall rules, Cloud Storage buckets, or IAM policies. Following Google-recommended practices, which role should you grant on the project?

Choose one.

  • a
    roles/compute.instanceAdmin.v1 Correct

    Correct. This predefined role covers creating, starting, stopping and modifying instances without network, firewall, storage or IAM administration.

  • b
    roles/compute.storageAdmin

    compute.storageAdmin manages persistent disks, images and snapshots. It does not let the engineer start, stop or reconfigure the instances themselves.

  • c
    roles/compute.admin

    compute.admin covers instances but also every other Compute Engine resource, including networks and firewall rules, which the engineer must not change.

  • d
    roles/compute.osAdminLogin and roles/compute.viewer

    Together these let the engineer see instances and log in to them with administrator rights on the guest OS, but they grant no Compute Engine API permission to start, stop or reconfigure instances.

The concept

Predefined roles are Google-maintained permission sets scoped to one service and job function. Several Compute Engine roles sound similar but cover different resources.

Why that’s the answer

The engineer needs instance lifecycle and configuration control and nothing else. roles/compute.instanceAdmin.v1 is the predefined role for exactly that. roles/compute.admin would also let them start and stop VMs, which makes it tempting, but it adds network and firewall administration the stem rules out. compute.storageAdmin covers disks and images, and osAdminLogin plus compute.viewer gives guest-OS login and visibility, not control of the instance resource.

How to reason it out
  1. List the actions required: start, stop, reconfigure instances.
  2. List what is forbidden: networks, firewalls, storage, IAM.
  3. Find the predefined role whose scope matches the allowed actions only.
  4. Eliminate roles that cover the wrong resource (disks, guest login) or too many resources (compute.admin).

Exam tip: Choose the predefined role scoped to the resource the person manages: instances means compute.instanceAdmin.v1, not compute.admin.

Managing Cloud IAM: Roles, Policies, and Inheritance — the lesson that teaches this.

Question 2Configuring access and security

A contractor was granted roles/editor on the folder that contains analytics-prod and five other projects. The security team asks you to remove the contractor's edit access to analytics-prod only, leaving the other five projects unchanged. Your organization does not use IAM deny policies. You hold Folder IAM Admin and Project IAM Admin, both granted on the folder. What should you do?

Choose one.

  • a
    Grant the contractor roles/viewer on analytics-prod; the folder grant still covers the five other projects

    Allow-policy grants only add. A Viewer binding on the project sits alongside the inherited Editor role, and the contractor keeps Editor on analytics-prod.

  • b
    Remove the contractor's Editor binding from the folder, then grant Editor on the five other projects Correct

    Correct. The access comes from the folder's policy, so it is removed there (Folder IAM Admin). Project IAM Admin, inherited from the folder, lets you grant Editor on the five other projects so their access stays unchanged.

  • c
    Run remove-iam-policy-binding on analytics-prod for the contractor's user and the Editor role

    The binding is not in the project's own policy; it lives in the folder's policy. The command finds nothing to remove there and the inherited grant stays in effect.

  • d
    Apply a set-iam-policy file to analytics-prod that omits the contractor's folder-inherited binding

    set-iam-policy replaces only the project's own allow policy. Inherited folder bindings are not part of that policy, so the contractor still holds Editor.

The concept

Allow policies are inherited down the hierarchy and are additive: a lower level can add access but cannot subtract access granted above it.

Why that’s the answer

The contractor's Editor role is granted in the folder's policy, so every project in the folder inherits it. Nothing written into analytics-prod's own allow policy can remove it: an extra Viewer binding just adds a role, remove-iam-policy-binding finds no binding in the project, and set-iam-policy rewrites only the project's own bindings. With deny policies ruled out, the fix is at the source: remove the folder binding and grant Editor on the five projects that should keep it.

How to reason it out
  1. Find where the access is granted: the folder's allow policy.
  2. Recall that allow policies are additive; a project policy cannot subtract an inherited role.
  3. Rule out project-level edits (adding a role, removing or replacing the project policy).
  4. Change the grant at the folder and re-create it only where it is still needed.

Exam tip: An inherited allow grant is changed where it was granted; editing a child's allow policy never removes it.

Managing Cloud IAM: Roles, Policies, and Inheritance — the lesson that teaches this.

Question 3Configuring access and security

A user holds roles/viewer granted at the organization level and roles/compute.instanceAdmin.v1 granted directly on the project vm-lab. No other bindings or deny policies apply to the user. What access does the user have in vm-lab?

Choose one.

  • a
    Read access across the project's services, because the organization-level grant takes precedence

    There is no precedence between hierarchy levels in allow policies. The organization grant does not cap or replace the project grant.

  • b
    Compute Engine instance management, because the project-level grant overrides the inherited one

    A more specific grant does not override an inherited one. The inherited Viewer role still applies alongside the project grant.

  • c
    Read access to Compute Engine, because IAM keeps just the permissions that both roles share

    IAM does not intersect roles. Permissions from every applicable binding are combined, not reduced to the overlap.

  • d
    Read access across the project's services plus management of Compute Engine instances Correct

    Correct. The effective policy is the union of all applicable bindings, so the inherited Viewer and the project-level instanceAdmin.v1 both apply.

The concept

The effective allow policy on a resource is the union of the bindings on the resource and on every ancestor.

Why that’s the answer

Allow policies never conflict, override or intersect: each binding contributes its permissions and IAM combines them. The user inherits Viewer from the organization and also holds instanceAdmin.v1 on vm-lab, so in vm-lab they can read across services and manage instances. Precedence (by level or by specificity) and intersection are the common misconceptions the distractors encode.

How to reason it out
  1. List every binding that applies to the user on vm-lab, including inherited ones.
  2. Recall that allow-policy bindings are combined, not ranked.
  3. Add the permissions of each role together to get the effective access.

Exam tip: Effective access = union of every applicable binding; no level or role overrides another.

Managing Cloud IAM: Roles, Policies, and Inheritance — the lesson that teaches this.

Question 4Configuring access and security

Your company wants one custom role for its deployment pipelines. The security team must maintain a single definition in one place, and the role must be grantable in every current and future project. All projects sit in folders under one organization. Where should you create the custom role?

Choose one.

  • a
    In the organization, then grant it on the projects or folders that need it Correct

    Correct. A custom role defined in the organization can be used in bindings on any project or folder in that organization, and there is one definition to maintain.

  • b
    In the top-level folder, then grant it on the projects or folders that need it

    Custom roles cannot be defined in a folder. Folders are a place to grant roles, not to own role definitions.

  • c
    In the first pipeline project, then grant it on the other projects that need it

    A custom role defined in a project can be used only in that project's bindings, so other projects cannot use it.

  • d
    In each pipeline project, keeping each copy's permission list identical

    This works technically, but it creates many definitions to keep in step, which breaks the single-definition requirement and invites drift.

The concept

Custom roles are created either in an organization or in a project; folders cannot hold custom role definitions.

Why that’s the answer

Where a custom role is defined decides where it can be used. An organization-level custom role can be granted on any resource in the organization, so one definition serves every project, including future ones. A project-level role is usable only inside its own project, so copying it into each project is the only way to reuse it, and that breaks the single-definition rule. A folder looks like a natural middle ground but cannot own a custom role.

How to reason it out
  1. Note the requirements: one maintained definition, usable in every project.
  2. Recall the two places a custom role can live: organization or project.
  3. A project-level role cannot be used elsewhere, and copies drift.
  4. Choose the organization level.

Exam tip: Shared custom roles go in the organization; project custom roles stay in their project; folders hold none.

Managing Cloud IAM: Roles, Policies, and Inheritance — the lesson that teaches this.

Question 5Configuring access and security

A platform team created an organization-level custom role and left it at the ALPHA stage while they refine it. A project owner, unaware of this, grants the role to the production SRE group on a project. What is the effect of that grant?

Choose one.

  • a
    The grant is rejected until someone moves the role's stage to GA

    Launch stage does not restrict who can grant a role. Only a DISABLED role behaves differently, and even that one can still appear in bindings.

  • b
    The grant succeeds and the group gets every permission in the role Correct

    Correct. ALPHA, BETA, GA and DEPRECATED are labels for administrators; a binding to a role at any of them grants all of its permissions.

  • c
    The grant succeeds but gives nothing until the role reaches BETA or GA

    That describes DISABLED, not ALPHA. An ALPHA role grants its permissions like any other.

  • d
    The grant succeeds and the group gets only the role's SUPPORTED permissions

    Support levels are not filtered at grant time. TESTING permissions in a custom role take effect too; they are just not guaranteed to stay stable.

The concept

A custom role's launch stage (ALPHA, BETA, GA, DEPRECATED, DISABLED) documents its maturity. Only DISABLED changes enforcement.

Why that’s the answer

Launch stages are metadata that tell administrators how far along a role is. IAM does not block grants of ALPHA or BETA roles and does not withhold their permissions, so the SRE group immediately gets everything in the role. That is exactly why an unfinished role is risky to grant. The tempting distractors describe DISABLED behaviour (bindings that grant nothing) or confuse launch stages with permission support levels.

How to reason it out
  1. Note the role's stage: ALPHA, not DISABLED.
  2. Recall that only DISABLED changes what a binding grants.
  3. Recall that support levels describe permissions and are not filtered at grant time.
  4. Conclude the grant takes full effect.

Exam tip: Launch stage is a label except DISABLED: an ALPHA or BETA custom role grants everything in it.

Managing Cloud IAM: Roles, Policies, and Inheritance — the lesson that teaches this.

Question 6Configuring access and security

An external consultant needs roles/bigquery.dataViewer on your project until their contract ends at 00:00 UTC on 31 March 2027. Policy requires the access to end on its own at that moment, without anyone running a command and without building automation of your own. Which condition should you put on the role binding?

Choose one.

  • a
    request.time > timestamp("2027-03-31T00:00:00Z")

    The comparison is reversed: this binding would grant nothing until the contract ends and then grant access indefinitely afterwards.

  • b
    request.time < timestamp("2027-03-31T00:00:00Z") Correct

    Correct. The binding applies only while the request time is earlier than the contract end, so it stops granting access automatically at that moment.

  • c
    request.time < duration("2027-03-31T00:00:00Z")

    duration() takes a length of time such as "3600s", not a date. A date must be compared using timestamp(), so this expression is invalid.

  • d
    request.time < timestamp("2027-03-31T00:00:00+05:00")

    The expression is valid, but the +05:00 offset makes the cutoff 19:00 UTC on 30 March, five hours before the contract actually ends.

The concept

IAM Conditions attach a CEL expression to a role binding; the binding grants its role only when the expression is true for the request.

Why that’s the answer

Time-bound access is a property of the binding, expressed as a condition on request.time. Comparing request.time with timestamp(...) using < keeps the grant valid until the cutoff and then lets it lapse with no cleanup. The reversed comparison and the wrong UTC offset are the closest twins: both are valid expressions that end access at the wrong moment. duration() is a real CEL function but measures a length of time, not a point in time.

How to reason it out
  1. Recognise the need: a grant that ends at a fixed time without manual work.
  2. Use an IAM condition on the binding with the request.time attribute.
  3. Compare it with timestamp() and pick the direction that is true before the deadline.
  4. Check the timestamp's offset matches the stated time zone (Z = UTC).

Exam tip: Temporary access = conditional binding with request.time < timestamp(END).

Managing Cloud IAM: Roles, Policies, and Inheritance — the lesson that teaches this.

What ACE domain 4 tests, topic by topic

The official exam guide breaks Configuring access and security into 2 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published ACE practice questions per topic in Configuring access and security
TopicWhat it coversQuestions
Managing IAMOfficial ACE exam-guide sub-section. Viewing and creating IAM policies; attaching roles and understanding policy inheritance in the Organization hierarchy; managing the various role types and defining custom IAM roles.44
Managing service accountsOfficial ACE exam-guide sub-section. Creating service accounts (including Google-managed); using service accounts in IAM policies with minimum permissions; assigning service accounts to resources; managing a service account’s IAM permissions; service account impersonation; creating and managing short-lived credentials; using a service account with a GKE application; provisioning Workload Identity Federation.44
Total88

Revise Configuring access and security before you drill it

Other ACE domains

Configuring access and security: your questions

Configuring access and security is domain 4 of the ACE exam guide and carries 20% of the scored content — the 3rd-heaviest of the 4 domains. On a 55-question paper that works out to roughly 11 questions, though Google Cloud does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official ACE exam guide.