Microsoft SC-500: Key Vault RBAC vs. Access Policies

Azure Key Vault RBAC vs Access Policies in 2026

Azure Key Vault supports two data-plane access-control models: Azure role-based access control and legacy vault access policies. Both remain supported, but their governance properties are different. Azure RBAC uses the same role-assignment system as other Azure resources and separates data-plane roles from ordinary resource management, while access policies store principal permissions directly on the vault resource.

The current SC-500 security model favors deliberate identity boundaries. Microsoft now makes Azure RBAC the default for new vaults created with Key Vault API version 2026-02-01 or later, while existing access-policy vaults continue using their current model unless explicitly migrated.

RBAC and access policies place authority in different systems

With Azure RBAC, access to keys, secrets, and certificates is granted through Azure role assignments at supported scopes. Roles such as Key Vault Secrets User or Key Vault Crypto Officer can be assigned to users, groups, managed identities, or service principals. The ability to create those assignments is controlled by Azure authorization, typically requiring Owner, User Access Administrator, or another role with role-assignment permission.

Access policies instead store permissions in the vault’s accessPolicies configuration. A principal with sufficient permission to modify the vault resource can historically add or change those policies. This difference matters because resource-management authority and secret-access authority can become more tightly coupled under the access-policy model. Azure RBAC provides a more consistent separation between managing the resource and granting data access.

New API versions change the default, not existing vaults

Starting with Key Vault API version 2026-02-01, a newly created vault defaults to Azure RBAC when the deployment does not explicitly set a different model. That behavior aligns automated deployments with the portal’s modern security direction. It does not automatically convert an existing access-policy vault merely because a template or SDK is updated to a newer API version.

This distinction prevents two migration mistakes. Teams should not assume existing vaults became RBAC-enabled silently, and they should not assume a control-plane API upgrade is the same project as an access-control migration. Microsoft treats those as separate tasks. Inventory should record both the API versions used by deployment tooling and the actual enableRbacAuthorization setting on each vault.

Microsoft’s Key Vault access model comparison and 2026-02-01 API behavior guidance establish an important version distinction: newly created vaults using that API version default to Azure RBAC, while existing vaults retain their access model until changed. Access policies remain supported but are treated as a legacy choice; do not describe them as universally removed or assume a portal screenshot represents every infrastructure-as-code deployment.

Switching to Azure RBAC invalidates existing Key Vault access policies and can break workloads that lack equivalent data-plane roles. Inventory applications and managed identities, stage appropriate least-privilege assignments, document an emergency recovery path and verify read/write operations after any migration. The Entra privileged identity and consent guide connects human privileged-role governance to the identities allowed to manage vault policy, but runtime secret-access permissions remain their own data-plane control.

Access policies remain supported but are now a legacy choice

Organizations can continue using access policies by explicitly setting the vault to that model, including for new vaults created with API version 2026-02-01 or later. That support matters for applications or operating models that cannot migrate immediately. The security tradeoff should be documented rather than hidden behind historical defaults.

A legacy model is not automatically insecure, but it can create broader privilege paths when contributors are allowed to modify vault configuration and thereby grant themselves data access. Teams that remain on access policies should tightly restrict who can update the vault resource, monitor policy changes, and review each principal’s permitted key, secret, and certificate operations.

RBAC makes scope part of the access decision

Azure RBAC can grant Key Vault data roles at management group, subscription, resource group, vault, or in some cases individual-object scope, depending on the role and supported scenario. Broader scopes are convenient for platform identities that legitimately manage many vaults, but they can make a compromise affect far more secrets than an application-specific assignment.

The safest design uses the narrowest operationally reasonable scope and prefers groups or managed identities over direct user assignments. Privileged access should be time-bound for human administrators where possible, with just-in-time activation and approval for roles that can read or administer sensitive vault data.

Migrating models can lock applications out immediately

Changing enableRbacAuthorization changes which data-plane authorization system Key Vault uses. Existing access-policy permissions do not continue authorizing secret or key operations once the vault switches to RBAC. A migration that enables RBAC before equivalent role assignments are in place can therefore cause an immediate application outage.

A safe migration inventories every current access policy, maps each principal to an RBAC role and scope, creates the required role assignments, tests application access, and only then changes the vault model. Rollback planning must consider propagation time and automation ownership. The migration is an identity change with production consequences, not a checkbox modernization exercise.

Control-plane permission is not data-plane permission

An Azure role such as Contributor can manage many aspects of the Key Vault resource without automatically granting permission to read secret values under the RBAC model. This separation is a major security advantage because infrastructure operators can manage networking, diagnostics, or resource settings while sensitive data access remains assigned to different identities.

Conversely, a workload identity can receive a narrow data role without gaining authority to reconfigure the vault. Key Vault secrets should be accessed by the application identity that needs them rather than copied into deployment scripts or operator accounts merely because those identities can manage Azure resources.

Networking and authorization solve different problems

Private endpoints, firewall restrictions, and public-network settings determine whether a client can reach the Key Vault service. RBAC or access policies determine whether the authenticated identity can perform the requested data operation. A request can therefore fail at the network boundary even with perfect role assignments, or reach the vault and fail because authorization is missing.

Troubleshooting should preserve that separation. DNS resolution, private endpoint routing, and firewall logs explain reachability; Azure activity and Key Vault diagnostics explain authorization and data-plane operations. Changing roles to solve a DNS failure weakens security without fixing the path, while opening public access to solve a missing role bypasses the intended network boundary.

Certificates and keys raise permission granularity questions

Applications that need only secret retrieval should not receive broad key or certificate administration roles. Key Vault has separate permission families because signing, key rotation, certificate issuance, and secret reading create different risks. Certificate management often involves automation identities whose required operations differ sharply from a web application that only reads a TLS secret.

Role design should start from the operation rather than from a desire to make access “work.” Test the application with the minimum role and add permissions only when a specific API call requires them. This reduces the chance that a compromised workload can rotate keys, alter certificates, or enumerate secrets unrelated to its purpose.

Managed identities simplify credential handling but do not remove authorization design. A system-assigned identity disappears with its resource, while a user-assigned identity can outlive individual workloads and be shared. Reuse can be convenient for a fleet, yet it also expands the blast radius of one Key Vault role assignment. The identity lifecycle should match the secret-sharing boundary rather than the convenience of deployment tooling.

Audit evidence should reveal who changed access

RBAC role assignments and vault configuration changes should be monitored because they change who can reach sensitive data. Activity logs can show control-plane role assignment or vault-model changes, while Key Vault diagnostic logs provide evidence about data operations. Access reviews can then compare intended owners with actual active assignments.

The same evidence should support incident response. If a secret was read unexpectedly, responders need to know which principal performed the operation, how that principal received authority, whether the assignment was permanent or activated through privileged identity management, and whether the network path was expected. Identity provenance is as important as the secret-access event itself.

The control-plane API retirement timeline should be tracked separately from authorization. Microsoft plans retirement of Key Vault control-plane API versions earlier than 2026-02-01 on February 27, 2027. Updating a script or template to the newer API is required for compatibility, but it does not by itself migrate an existing vault from access policies to RBAC.

The model choice should be explicit in deployment code

Infrastructure templates should set and validate the intended access-control model rather than relying on historical platform defaults. This is especially important during the transition to the 2026-02-01 API behavior. An old template and a new template can create vaults with different defaults even when the surrounding configuration looks similar.

Policy-as-code can require Azure RBAC for new vaults, restrict public access, and validate diagnostic settings. Applications should then receive narrowly scoped roles through a separate deployment step owned by the appropriate identity authority. The result is predictable: a new vault does not inherit access merely because an infrastructure contributor created it.

Break-glass access should be rare and predesigned. If an application outage requires emergency secret retrieval, the organization should know which identity can activate the required role, how the activation is approved and logged, and how the role is removed afterward. Granting permanent broad access “for emergencies” defeats the separation that RBAC is meant to provide.

RBAC is a governance improvement only when roles stay narrow

Moving from access policies to RBAC does not automatically create least privilege. A subscription-wide Key Vault Administrator assignment can be more dangerous than a carefully scoped access policy on one vault. The value of RBAC comes from centralized role governance, clearer grant authority, privileged identity integration, deny assignments, and consistent scope—not from the acronym itself.

A mature Key Vault design can state which access model each vault uses, why, which principals can grant data access, what scope each workload role covers, how human privilege is activated, and how migrations avoid lockout. That clarity turns the platform’s access-control choice into a manageable security boundary instead of an inherited historical setting.

Leave a Reply

How It Works

img
Step 1. Choose Exam
on ExamLabs
Download IT Exams Questions & Answers
img
Step 2. Open Exam with
Avanset Exam Simulator
Press here to download VCE Exam Simulator that simulates real exam environment
img
Step 3. Study
& Pass
IT Exams Anywhere, Anytime!