Microsoft Fabric

Microsoft Fabric Security Architecture for Production Data Platforms

An architect's guide to securing production Microsoft Fabric platforms: threat model, identities, workspace boundaries, data-level controls and their bypass paths, multi-tenant isolation patterns, tenant context, secrets, networking, service identities, auditing and blast radius, with a reusable review checklist.

By JaviPublished 29 min readAdvanced

On this page

Most Fabric security problems are not missing features. They are paths nobody mapped: a report protected by row-level security while the same table is readable through the SQL endpoint, a pipeline that quietly runs as whoever edited it last, a shortcut that makes one customer’s folder visible from another customer’s workspace. This guide answers one question:

How should I design security in Microsoft Fabric so identities, workspace boundaries, data access, networking, secrets, operations and tenant isolation all work together?

The architectural principle. Security is only as strong as the least-controlled path to the data. A design is not secure because one access path is protected. The same Delta table can be reached through a workspace role, a Warehouse or SQL analytics endpoint, a semantic model, a notebook, a pipeline, the OneLake APIs, a shortcut in another workspace, an external application or a service identity, and each of those paths is enforced by a different mechanism. The architect’s job is to list every path and decide what protects each one.

  1. Customer orders tableDelta table in OneLake
    • DAX
      Model RLS / OLSSemantic modelApplies to Viewers only, not to builders
    • T-SQL
      SQL or OneLake rulesSQL endpoint or WarehouseDepends on the item and the endpoint's access mode
    • Spark
      OneLake securityNotebook / SparkBuilders read everything in the workspace
    • service run
      Run identityPipeline or jobRuns as the pipeline's last modifier or a connection
    • ADLS API
      OneLake securityOneLake APIAlso needs the external-apps tenant setting
    • shortcut
      Passthrough or delegatedShortcut elsewhereUser identity or the connection's credential
One table, many paths. The same Delta table is reachable through at least six paths, and each is governed by a different control. Protecting one path, for example with semantic-model RLS, leaves the others exactly as open as before.

This is the second architecture flagship on Javi Builds. Designing a Production Data Platform places security among the decisions to make before building; this article goes deep on that one decision. It is not a role-assignment tutorial or a feature list. Every Microsoft-documented fact is linked in Sources; the frameworks, patterns and recommendations are Javi Builds architectural guidance, and are written as recommendations.

Terminology: three kinds of “tenant”

The word “tenant” is overloaded in this topic, so this article keeps three meanings apart:

Term Meaning here Example
Platform tenant (customer) A customer, business entity, partner or other logically isolated consumer of your data platform One of the 60 retail customers of an analytics product
Entra tenant A Microsoft Entra ID directory: users, groups, service principals Your organization’s directory; a partner’s directory
Fabric tenant The Fabric environment attached to one Entra tenant, with its tenant settings and capacities Everything your Fabric admins govern

“Multi-tenant” in this article always means many platform tenants served by one Fabric platform, unless it says Entra tenant explicitly.

The running example

One generic scenario keeps the decisions concrete. A company runs an analytics product for about 60 business customers. Customers read dashboards and download extracts through a web application; three large customers also want direct SQL access to their own data. The same Fabric platform serves the company’s internal finance and operations teams, and contains customer contact details and payment data. The scenario is invented and contains no real customer or employer details.

The security layers

The rest of the article walks through these layers in order. Each one narrows access for the next, and none replaces another: a strong network boundary does not make a broad workspace role safe, and a precise row filter does not help if a builder role bypasses it. Governance, secrets, audit and tenant context cut across all of them.

  1. Identity

    • People in groupsEntra ID, Conditional Access
    • Workload identitiesService principals, workspace identity
  2. Network

    • InboundTenant or workspace private links
    • OutboundGateways, managed private endpoints, OAP
  3. Workspace

    • BuildersAdmin, Member, Contributor: full data access
    • ConsumersViewer: subject to data rules
  4. Item

    • Item permissionsRead, ReadData, ReadAll, Build, Reshare
    • Shortcuts and sharesPassthrough, delegated, external
  5. Data

    • OneLake securityTables, folders, RLS, CLS
    • SQL permissionsGRANT, RLS, CLS, masking
    • Model securityRLS, OLS for report readers
  6. Consumer

    • Reports
    • Applications and APIs
    • Notebooks and SQL clients

Cross-cutting concerns

  • Governance
  • Secrets
  • Audit
  • Tenant context
Microsoft Fabric security architecture as layers of decisions. Each tier narrows access for the next; no tier replaces another. Governance, secrets and audit cut across every tier, and tenant context must survive all of them.

Threat model before controls

Start with three questions before choosing a single control:

What are we protecting, from whom, and through which access paths?

This is not a formal threat-modeling method. It is a practical list of the ways Fabric platforms actually leak or break, so each control in the rest of the article has a reason to exist:

Threat How it usually happens Primary architectural control
Accidental cross-tenant access A shared table without an enforced tenant filter; a query, view or extract that forgets the predicate Isolation pattern chosen per customer class; filter enforced below the application
Excessive workspace privilege Consumers added as Contributor or Member “so they can see everything” Builders and consumers in different workspaces and roles
Compromised service identity One service principal with Contributor on every workspace; its secret leaks One identity per workload and boundary; least privilege; no shared secrets
Leaked secret Credentials in notebook code, pipeline JSON, Git or a configuration file Workspace identity or Key Vault references; secrets never in definitions
SQL access bypassing semantic-model controls RLS defined only in the semantic model; users also have SQL endpoint access Enforce rules where every path reads: SQL permissions or OneLake security
Notebook or pipeline access to sensitive data Engineers with Contributor in production read personal data through Spark Production workspaces restricted; sensitive data separated or masked
Misconfigured sharing Item shared with Reshare, then re-shared outside the intended audience Sharing policy, access reviews, audit of sharing events
External-user access B2B guests added to roles or groups without lifecycle; cross-tenant data shares forgotten Guest access reviews; external data shares owned and reviewed
Network exposure Public access when policy requires private; sources opened to the internet for Fabric Private Link, gateways and trusted access chosen by requirement
Stale access after role changes People keep group membership or direct grants after moving teams Group-based access and recurring reviews
Production credentials in development Dev pipelines connected to production sources with a production secret Separate identities, connections and data per environment

Each row becomes a test later: for every threat, the review checklist asks how the design prevents it and how that was verified.

Identity architecture

Every request to Fabric is authenticated by Microsoft Entra ID. The identity design decides two things: who can do what, and what still works when people leave.

Human identities and workload identities

Separate the two from the start:

  • User identities belong to people: analysts, engineers, administrators, customer users. They come and go, change teams and go on holiday.
  • Workload identities belong to processes: scheduled pipelines, deployments, applications, integrations. In Fabric these are service principals (Entra app registrations) and workspace identities. A workspace identity is an automatically managed service principal that Fabric creates for a workspace; Fabric manages its credentials, and it can authenticate connections and enable trusted access to firewall-enabled ADLS Gen2.

Azure managed identities belong to Azure resources. Inside Fabric, the closest equivalent is the workspace identity, but Microsoft is explicit that its lifecycle, administration and governance differ: it belongs to the workspace, is deleted when the workspace is permanently deleted, isn’t granted any workspace role by default, and isn’t supported in B2B or cross-tenant scenarios.

Design rules that hold across both kinds:

  • Groups, not individuals. Assign workspace roles, item permissions and OneLake security roles to Entra security groups. Joining or leaving a team becomes one identity change, reviewed in one place.
  • Every non-human identity has a named owner and a purpose. “Deployment to Sales PROD” is a purpose; “the Fabric SPN” is not.
  • No shared credentials. Two pipelines, two teams or two customers do not share one secret.
  • Least privilege by boundary. An identity gets the narrowest role on the fewest workspaces that its job needs.
  • Lifecycle is designed. Rotation, expiry and removal are part of the design, not an incident response.

Choosing the identity pattern

Need Preferred identity pattern Why
Internal analyst reading curated data User in an Entra group; Viewer or item permission plus data-level rules Access follows the person; data rules can apply because Viewers are subject to them
Report consumer User in a group with access to an app or report; semantic-model RLS where needed No workspace role needed for consumption
Customer user of an analytics product Application identity calling Fabric, with the customer resolved by the application; or a B2B guest only when direct access is required Most customers should never hold a Fabric role; the application enforces tenant scope
Scheduled pipeline in production Service principal as the pipeline’s last modifier, or workspace identity in connections The run must not depend on a person’s account staying active and unchanged
Automation and deployment (CI/CD) Dedicated service principal per environment, Contributor or Admin only where it deploys Deployment is privileged; it should be one auditable identity, not a person
Cross-workspace processing Workload identity with the minimum role on each workspace, or OneLake shortcuts with passthrough Explicit, reviewable dependency instead of broad roles
Connecting to firewall-enabled ADLS Gen2 Workspace identity with trusted workspace access No stored secret; access limited to that workspace (requires an F SKU)
Source without Entra authentication Connection credential stored as an Azure Key Vault reference Secret stays in the vault; rotation happens in one place
External partner reading your data OneLake external data sharing for their own Fabric tenant, or B2B guest access for interactive use Data shares are read-only and in place; guests are governed like users

Two documented constraints shape this table. Service principals must be enabled by a Fabric admin (the “Service principals can call Fabric public APIs” setting is off by default). And some downstream services, Microsoft notes the SQL analytics endpoint as one example, don’t accept service principals and require a user principal, so check each step of a pipeline before assuming one workload identity covers it end to end.

Workspace security boundaries

Workspaces are one of the most important security decisions in a Fabric platform, because a workspace role applies to every item in the workspace. Drawing workspace boundaries is drawing blast-radius boundaries.

What the roles actually grant

The table below summarizes Microsoft’s documented workspace capabilities that matter for security design:

Capability Admin Member Contributor Viewer
Add or remove people, including admins Yes Members and lower No No
Create, modify or delete items, including Lakehouses and Warehouses Yes Yes Yes No
Edit OneLake security roles Yes Yes No No
Read Lakehouse and Warehouse data with T-SQL (ReadData) Yes Yes Yes Yes
Read data through Spark and OneLake APIs (ReadAll) Yes Yes Yes No, unless a OneLake security role grants it
Run notebooks and pipelines Yes Yes Yes No
Create the workspace identity; connect Git Admin only No No No

Two consequences are easy to miss:

  1. Admin, Member and Contributor are full data access. Microsoft documents that OneLake security roles and semantic-model RLS don’t restrict these roles, and its Warehouse guidance reserves them for people actively collaborating on the solution. There are narrow documented exceptions, for example OneLake RLS in the SQL analytics endpoint’s user identity mode applies to all users, but the safe design assumption is: anyone who can build in a workspace can read everything in it.
  2. Viewer is not “no data access”. Viewers can connect to SQL analytics endpoints and Warehouses and read data through T-SQL. Whether they see every row depends on SQL permissions or OneLake security, which you have to configure. Viewer is the role that data-level rules apply to; it is not itself a data restriction.

Drawing the boundaries

Separate workspaces by When Security effect
Environment Always, once anything is consumed Development access never implies production data access
Builders and consumers When consumers need access to production data Consumers get Viewer or item access in a serving workspace; builders’ rights stay in engineering workspaces
Domain or owner Different data owners or regulations Each owner controls who builds and reads their data
Sensitivity A subset of data is far more sensitive than the rest Fewer people hold builder roles where the sensitive data lives
Operational team Ingestion, transformation and serving run by different teams Each team’s privileges stop at its own stage
Application team An application owns its serving data The application’s identity is scoped to its workspace
Platform tenant Isolation pattern C or D (below) A customer’s data and roles stop at a workspace boundary

A common, defensible layout separates engineering workspaces (where data is ingested and transformed, with few builders) from serving workspaces (curated tables, Warehouses and semantic models, where consumers hold Viewer or item permissions). Shortcuts or loads connect them. The rest of the article builds on that split.

Data-level security

Workspace roles decide who is in the room. Data-level controls decide what a reader sees once inside. The key question for each one:

Can a user bypass the intended control through another engine?

Fabric has several data-level mechanisms, and each protects a specific path:

Control Protects Does not protect
Semantic-model RLS and OLS DAX queries through that model, for Viewers Admins, Members and Contributors; the SQL endpoint, Warehouse, Spark or OneLake reading the same tables; service principals, which can’t be RLS role members
Warehouse SQL permissions, RLS, CLS, dynamic data masking T-SQL against that Warehouse The same data read through a OneLake shortcut: Microsoft documents that Warehouse SQL security isn’t translated into OneLake security, so shortcut readers might see the full data
SQL analytics endpoint, delegated identity mode (the default) T-SQL, governed by SQL GRANT, RLS, CLS and masking Spark and OneLake paths; OneLake security rules don’t apply to SQL queries in this mode, and the endpoint reads OneLake as the item owner
SQL analytics endpoint, user identity mode T-SQL, governed by OneLake security roles passed through with the user’s identity Dynamic data masking isn’t supported; SQL GRANT on tables is ignored
OneLake security roles (tables, folders, RLS, CLS) Spark, OneLake APIs, SQL endpoint in user identity mode, Direct Lake on OneLake, for Viewers and Read-permission users Admins, Members and Contributors (with documented exceptions); paths that read as an owner identity
Workspace roles Everything in the workspace Nothing inside it: they are the coarse boundary

Three bypass examples, all of them common:

  • RLS in the semantic model, direct Warehouse access. A report filters each region’s managers to their region. The same managers are Viewers in the workspace, so they can also connect to the Warehouse with SSMS, where no SQL RLS exists. The report is secure; the data is not.
  • SQL endpoint secured, notebook open. Delegated-mode SQL permissions hide a payment table from analysts. A data scientist who is a Contributor reads the same Delta table from a notebook. SQL rules never apply to Spark.
  • Workspace role over a lower-level rule. A OneLake security role restricts a customer support group to non-sensitive columns. Someone later adds the group as Member “to let them publish a report”, and every column becomes readable.

Javi Builds guidance: decide, per dataset, where the authoritative rule lives, then make every other path either enforce the same rule or be closed:

  • If many engines read the data, prefer OneLake security with the SQL analytics endpoint in user identity mode, so one rule applies across Spark, SQL and Direct Lake on OneLake.
  • If the data is consumed only through T-SQL and a semantic model, SQL permissions in a Warehouse plus a semantic model that reads through them can be enough, as long as no shortcut exposes the same files.
  • Treat semantic-model RLS as a presentation-layer rule for report consumers, never as the only protection of data that people can reach another way.
  • Test every rule through every path a real user has, using real identities rather than “test as role” simulations, which Microsoft notes don’t reproduce every identity context.

Multi-tenant architecture

This section is about serving many platform tenants: customers, business entities, partners or other logically isolated consumers of one platform. The question is how strongly their data and operations are separated, and what that separation costs.

Microsoft Fabric gives you several isolation levels to build with: rows in shared tables, schemas or folders inside an item, items, workspaces and capacities. They combine into four patterns.

  1. 1Isolation · low–mediumShared storeTenant ID column in shared tables; lowest cost
  2. 2Isolation · mediumSchema-separatedSchema or folder per tenant in shared items
  3. 3Isolation · highWorkspace per tenantRoles, items and lifecycle per customer
  4. 4Isolation · very highDedicatedOwn workspace, store and capacity; highest cost
The multi-tenant isolation spectrum. Each step down the spectrum increases isolation and shrinks the blast radius, and increases cost and operational work. Most real platforms mix patterns by customer class rather than picking one.

Pattern A: shared workspace, shared data store

All tenants’ rows live in the same tables, distinguished by a tenant_id column; isolation is logical.

  • Pros: the most efficient model; one pipeline, one schema, one deployment; the lowest cost per tenant.
  • Risks: the largest blast radius; every access path must enforce the tenant filter; a single missing predicate in a view, extract or ad hoc query exposes every customer.
  • Appropriate when: tenants have similar requirements, regulatory isolation needs are limited, tenants consume through an application or semantic model that you control, and the security model is mature and tested.

Fabric specifics to weigh: OneLake security can filter rows per role, but roles combine as a union (a user in two tenant roles sees both tenants), an item supports 250 OneLake security roles by default (1,000 on request), each role supports up to 500 members, and group membership changes take about an hour to apply. Per-tenant roles for direct customer access therefore scale poorly beyond a modest number of tenants. Pattern A works best when customers never query Fabric directly and the application, or a semantic model with dynamic RLS or an embedded effective identity, applies the tenant scope.

Pattern B: shared workspace, separate schemas or tables

Each tenant gets its own schema (in a Warehouse or a schema-enabled Lakehouse) or folder; the workspace and items are shared.

  • Pros: clearer boundaries; schema- or folder-level grants instead of row predicates; tenant-specific operations (reload, delete, export one customer) become simpler.
  • Cons: metadata grows with every tenant; deployments must create and evolve N schemas; cross-tenant reporting needs unions; and workspace roles still span every tenant, so builders and the platform’s service identities see all of them.

Pattern C: workspace per tenant

Each customer gets its own workspace (often one per environment), deployed from the same definitions.

  • Pros: a strong operational boundary; workspace roles, sharing, workspace identity, Git connection and lifecycle are per customer; offboarding is a workspace deletion; the blast radius of a mistake is one customer.
  • Cons: workspace sprawl; automation becomes mandatory (creation, role assignment, deployment and configuration through the REST APIs or a CI/CD tool, never by hand); monitoring and governance must aggregate across many workspaces; capacity is still shared unless you separate it.

Pattern D: dedicated data store, workspace and capacity

A customer gets its own workspaces on its own capacity, and possibly its own encryption key and network configuration.

  • Use when: regulatory or contractual isolation requires it; a noisy-neighbor risk is unacceptable; the customer has a dedicated SLA, region or recovery requirement; or the tenant is large enough to justify its own capacity.
  • Cons: the highest cost; every capacity is sized, monitored and paid for separately; operational complexity grows with each dedicated customer.

Capacity is a real isolation lever here, not only a performance one: throttling, smoothing and the disaster recovery setting all apply per capacity, and workspace customer-managed keys allow a key per workspace. The Fabric Capacity Planner helps size a dedicated capacity from measured utilization instead of guessing.

Multi-tenant decision matrix

Requirement Shared store Schema-separated Workspace per tenant Dedicated
Isolation strength Low to medium; depends entirely on enforcement Medium High Very high
Cost efficiency High High Medium; shared capacity keeps it reasonable Low
Operational complexity Low, until enforcement must be proven Medium High; requires automation High
Blast radius of one mistake All tenants Usually all tenants in the workspace One tenant One tenant, including capacity
Customization per tenant Low Medium High Highest
Regulatory fit Limited; must be argued and tested Moderate Strong for most contractual isolation Strongest available inside one Fabric tenant
Noisy-neighbor protection None None None unless capacities are separated Yes
Onboarding a tenant Insert configuration rows Create schema and grants Provision workspace, roles and deployment Provision capacity, workspaces and deployment

None of these cells is absolute. A well-enforced shared store can be safer than a hundred hand-built workspaces with drifting role assignments.

Javi Builds guidance: classify customers first and apply patterns per class. A common shape for the running example is shared ingestion and conformance (Pattern A in engineering workspaces, never exposed to customers), serving through the application for most customers (Pattern A with application-enforced scope), and workspace per tenant (Pattern C) for the three customers who need direct SQL access, with Pattern D reserved for a customer whose contract demands dedicated capacity.

Tenant isolation controls

Whatever the pattern, these controls carry the isolation:

Control What it does Design rule
Tenant ID propagation Every row, file and run carries its tenant Tag at ingestion; never infer the tenant later from a file name or path alone
Tenant-aware authorization Resolves which tenants a caller may access Derived from the authenticated identity and a trusted mapping, not from a request parameter
Enforced filtering Applies the tenant predicate below the client In SQL RLS, OneLake security, the semantic model or a server-side query layer; never only in the UI
Schema or store separation Puts tenants in different containers Use when filters alone can’t meet the isolation requirement
Workspace boundaries Separates roles and lifecycle per tenant Patterns C and D; deployment automated
Pipeline isolation Stops one tenant’s load from writing another’s data Tenant parameter validated against configuration; per-tenant targets or partitions
Service identity isolation Limits what one compromised identity can reach Per-tenant or per-tenant-group identities for patterns C and D
Tenant-specific secrets Stops one customer’s credential from opening another’s source One Key Vault secret per customer connection; no shared credentials
Tenant ID in logs Makes incidents and audits answerable per customer Every execution log and audit record carries the tenant
Cost attribution Makes per-tenant cost visible Tenant on runs and queries; separate capacities where chargeback must be exact
Usage isolation Stops one tenant exhausting shared capacity Concurrency and request limits per tenant in the application; capacity separation for large tenants

Tenant context propagation

Tenant isolation is only as good as the tenant context that reaches the data. The context must flow, unchanged and verified, through every hop:

  1. 1User or applicationSigns in; may request a customer
  2. 2IdentityEntra token proves who is calling
  3. 3Tenant authorizationTrusted mapping decides which tenants are allowed
  4. 4Query or pipelineTenant predicate, schema or workspace applied
  5. 5DataEnforced filter or isolated store returns one tenant
  6. 6Audit and loggingTenant, identity and operation recorded together
Tenant context propagation. The tenant is resolved once, server-side, from the authenticated identity, then carried through every hop to the data and the audit record. A hop that loses or re-derives it is where cross-tenant leaks and unanswerable incidents start.

When the context is lost, two kinds of problems follow. Security problems: a query runs without its predicate, a pipeline writes one tenant’s data into another’s target, a cached result is served to the wrong customer. Operational problems: a slow query, a failed load or a capacity spike can’t be attributed to a customer, so support can’t answer “was my data affected?” and finance can’t charge back. The Report Engine architecture shows the application side of this flow, including why mandatory tenant predicates must never be overridable by user-defined report metadata.

Multi-tenant anti-patterns

  • Trusting a tenant ID supplied by the client (?tenantId=42) without validating it against the caller’s authorized scope.
  • Filtering only in the UI, so any direct query, export or API call returns all tenants.
  • One service principal with unrestricted access everywhere, used by every pipeline for every customer.
  • Shared secrets across tenants, so rotating or revoking one customer’s access affects all of them.
  • Relying only on semantic-model RLS while customers or support staff can reach the underlying tables through SQL, Spark or shortcuts.
  • Copying tenant data into shared staging without tenant tagging, so a later step can’t tell whose rows it holds.
  • Logs without tenant identifiers, which makes “which customers were affected?” a manual investigation.
  • Manual workspace-per-tenant deployment, which guarantees drift between customers within months.
  • Giving customer users Contributor or Member when Viewer plus data-level rules, or item access, is enough.

Environment separation

Development, test and production need different workspaces, but the boundary is only real if more than the workspace changes:

Separate Rule
Workspaces One per environment (and per tenant where pattern C applies); production edited only through deployment
Identities Different deployment and run identities per environment; the dev identity has no role in production
Connections and credentials Separate connections and secrets per environment; production secrets never referenced from non-production
Data No production personal data in development; use synthetic, sampled or masked data
Access Engineers are builders in development, readers (at most) in production
Configuration Environment-specific values parameterized, for example in variable libraries, never hand-edited after deployment

Test-data sanitization deserves its own owner. “We copied production to test for one bug” is how production personal data ends up in a workspace with ten Contributors.

Where tenant and environment boundaries intersect

In a multi-tenant platform you have to decide whether environments are per tenant:

Option Shape Tradeoff
Per tenant, per environment prod-customer-a, test-customer-a, dev-customer-a Strongest separation and per-customer testing; workspace count multiplies by environments
Per tenant in production, shared non-production prod-customer-a, prod-customer-b; one test and one dev with synthetic tenants Far fewer workspaces; tenant-specific customizations must be testable with synthetic tenants
Per tenant only where customized Shared non-production, plus test-customer-c for the one customer with custom logic Balanced; requires a clear rule for when a customer earns its own test environment

Javi Builds guidance: start with per-tenant production and shared non-production using synthetic tenants, and add tenant-specific test environments only for customers with customized logic or contractual testing requirements. Whatever the choice, non-production must never hold a real customer’s data without that customer’s agreement.

Secrets and credentials

The principle is simple:

Secrets should not become configuration files.

A secret that lives in a notebook cell, a pipeline parameter, a JSON definition or a Git repository has already been distributed to everyone who can read that artifact, including every Viewer who can read notebook and pipeline content.

Need Preferred approach Why
Source that supports Entra authentication Workspace identity or a service principal in the connection No long-lived secret for you to store or rotate
Source that needs a password, key or token Azure Key Vault reference in a Fabric connection Fabric stores only the vault and secret name and fetches the current secret at run time
Code that must call an external API Read the secret from Key Vault at run time, as the identity running the code Nothing sensitive in the definition or in Git
Environment-specific values (endpoints, IDs, paths) Parameters or variable libraries Configuration varies by environment; secrets stay in the vault
Per-tenant credentials One secret per tenant connection Revoking one customer never touches another

Key Vault references come with documented limits worth designing around: they always resolve the latest secret version (no version pinning), they’re created through Manage connections and gateways rather than the Get Data experience, and support varies by connector and authentication type. Rotation therefore means writing a new version and verifying that every dependent connection still works, ideally in test before production.

Rotation needs an owner and a schedule, and service principal credentials need expiry dates on purpose. A secret that “never expires” is a secret nobody has rotated.

Networking and connectivity

Network design decides where traffic can come from and go to. It does not decide who may read which data.

Network isolation is not authorization. Private connectivity reduces who can reach the platform; identity and data-level controls still decide what each caller can read.

Requirement Network approach Notes
Restrict access by IP range, MFA, device or location Microsoft Entra Conditional Access Evaluated when identities authenticate to Fabric
No public access to the whole Fabric tenant Tenant-level Private Link with Block public Internet access Broad impact: some features are unavailable, and on-premises data gateways aren’t supported while it’s on; VNet data gateways work
Private access for some workspaces only Workspace-level private links Item support varies; most data items are GA, some are Preview
Control where workspace items can connect out Workspace outbound access protection, with managed private endpoints or data connection rules as exceptions Item support varies; some items are Preview
Spark reaching private Azure sources Managed private endpoints from the workspace’s managed virtual network Enabling Private Link provisions a managed virtual network for Spark
Reading a firewall-enabled ADLS Gen2 account Trusted workspace access with a workspace identity Requires a purchased F SKU capacity
Reaching on-premises sources On-premises data gateway Not supported with tenant-level Private Link enabled
Reaching sources inside an Azure virtual network VNet data gateway Managed gateway injected into your network

Two documented facts are worth repeating in every design review. Private endpoints protect traffic into Fabric; they don’t guarantee that traffic from Fabric to your sources is secured, so the sources need their own firewall and network rules. And Private Link works within one tenant boundary: cross-tenant shortcuts and OneLake external data sharing don’t work over it, so a fully private design and cross-tenant sharing are mutually exclusive today.

Check the current security feature availability table before relying on a specific item: support for workspace private links, customer-managed keys and outbound access protection is tracked per item, and several items are still in Preview.

Cross-workspace and cross-domain access

Data products are meant to be shared. The architecture decides how they are shared, so sharing doesn’t quietly widen access.

Mechanism How access is decided Watch for
OneLake shortcut, passthrough (default for OneLake-to-OneLake) The querying user’s identity is checked on both the shortcut path and the target Users need rights on both sides; owner-identity paths behave differently
OneLake shortcut, delegated (always for external sources) A configured connection credential reads the target; OneLake security limits what callers see through it Anyone authorized on the shortcut path reads with the connection’s access to the source
Warehouse data read through a shortcut OneLake permissions, not Warehouse SQL rules Warehouse RLS, CLS and object grants don’t carry over
SQL endpoint in delegated mode, Direct Lake on SQL The consumer item’s owner identity reads OneLake Use user identity mode or Direct Lake on OneLake for end-to-end user identity
External data sharing (another Fabric tenant) Read-only, in-place shortcut in the consumer tenant Any user in the consumer’s tenant can be granted access; provider-tenant labels and DLP don’t apply there
Item sharing with Reshare Item permission, re-shareable Re-sharing chains outside the intended audience

Central versus domain-owned data is a question of who approves access: a central platform team can own shared reference data, while each domain owns and approves access to its products. In both cases, record the dependency: which consumer reads which producer, through which shortcut or load, as which identity.

For multi-tenant platforms one rule matters above the rest:

A shortcut must not accidentally broaden access to another tenant’s data.

In practice: point per-tenant shortcuts at per-tenant paths, never at a shared folder that contains every customer; use passthrough where possible so the caller’s own rights are evaluated; avoid delegated shortcuts whose connection can read more than one customer’s data; and don’t name shortcuts after customers in shared locations, because OneLake lists internal shortcuts regardless of whether the caller can open the target.

Service-to-service security

Most Fabric work runs without a person watching. Every investigation, security review and permission error eventually asks:

What identity is actually performing the operation?

Operation Identity to verify
Interactive notebook run The signed-in user
Notebook run from a pipeline The pipeline’s last modified user or service principal, or the connection identity configured in the Notebook activity (for example a workspace identity)
Scheduled notebook run The user who created or last updated the schedule
Pipeline run The pipeline’s last modifier; set it to a service principal for production runs
Copy activity, Copy job, Dataflow, external shortcut The connection’s credential: user OAuth, service principal, workspace identity or a Key Vault-referenced secret
SQL analytics endpoint in delegated mode The caller for SQL permissions; the item owner for reading OneLake
Direct Lake on SQL / Direct Lake on OneLake The owner or fixed identity / the user (passthrough)
Deployment and REST automation The service principal used by the pipeline or CI/CD tool
Embedded report with a service principal The service principal, plus the effective identity passed in the embed token

The pipeline row is the one that surprises teams most often. Microsoft documents that a notebook triggered by a pipeline runs as the pipeline’s last modifier, not the pipeline or notebook owner. Whoever last edited the pipeline determines the data access of every run. In production that should be a dedicated service principal (a service principal that edits the pipeline through the REST API becomes its last modifier), never an engineer’s account that might gain or lose rights tomorrow. A related habit protects against a different risk: before adding a notebook to a pipeline or a schedule, review who last changed its code, because it will run with someone else’s identity.

Data classification and sensitive data

Governance and security work together but are not the same thing:

Governance tells you what the data is and who owns it; security controls who can use it.

A sensitivity label on a table doesn’t stop anyone from reading it. It tells everyone, and every downstream tool that supports labels, what the data is, so the right security controls can be chosen and checked.

Data class Examples Minimum architectural controls
Personal data (PII) Names, emails, addresses, customer identifiers Label; restrict builder roles where it lives; column-level security or masking for most readers; deletion procedure
Financial data Revenue by customer, payment details, margins Label; separate serving workspace; row- or object-level rules by role
Regulated data Health, payment card or sector-specific data Dedicated workspaces or capacity; network restrictions; audit retained to the regulation’s term
Tenant data Any customer’s data in a multi-tenant platform Isolation pattern; tenant ID on every row and log; cross-tenant tests
Internal Operational metrics, reference data Standard workspace roles and reviews

Microsoft Purview sensitivity labels classify Fabric items and follow data to supported exports, and lineage shows where labelled data flows. Retention is part of the same decision: personal data needs a deletion path that reaches raw landing, history tables and backups, not only the serving model. The Fabric governance guide covers domains, labels, lineage and endorsement; this article only adds the security consequence of each class.

Auditing and observability

A security architecture that can’t be observed can’t be trusted. Plan where each kind of evidence comes from before an incident needs it:

Evidence Where it comes from
Authentication and sign-ins, including service principals Microsoft Entra sign-in and audit logs
Workspace, role, sharing and permission changes The Fabric audit log, searchable in Microsoft Purview Audit
OneLake security role, shortcut and sharing changes The Fabric audit log
Data access through OneLake OneLake diagnostics, enabled per workspace: who accessed what, when and how, including access through shortcuts
SQL activity on Warehouses and SQL endpoints Warehouse SQL audit logs
Pipeline and service identity behavior Run history plus your own execution log, recording the executing identity
Tenant or customer context Your execution log and application logs, with tenant_id on every record
Admin and tenant-setting changes The Fabric audit log

OneLake diagnostics writes events to a lakehouse in the same capacity, including the executing principal, whether access went through a shortcut, and the caller’s IP address. It can be made immutable for a retention period, and identifiers can be redacted by a tenant setting. For Fabric workloads it records that access was granted, so engine-specific logs supply the detail.

Turn evidence into signals: alert on role changes in production workspaces, on new external data shares, on access from unexpected identities, and on authorization failures that spike after a deployment. For multi-tenant platforms, every log record that touches customer data should carry the tenant ID, so “was customer A affected?” is a query, not an investigation. Designing an Execution Log gives the run-record schema to extend with tenant_id and the executing identity, and Monitoring Fabric Pipelines and Notebooks covers what Fabric’s built-in monitoring shows.

Blast-radius design

Every security architecture should be able to answer one question for each identity, workspace and process:

If one identity, workspace or process is compromised, how much data can it access?

If this is compromised… It can reach… Design to shrink it
A builder’s account in a shared workspace Every item and all data in that workspace Fewer builders in production; separate engineering and serving workspaces
A platform-wide service principal Every workspace it holds a role on One identity per workload and boundary; no tenant-wide automation identities
A per-tenant workspace identity That tenant’s workspace and sources it can authenticate to Workspace per tenant for high-isolation customers
A shared connection credential Everything the credential reads, from every item that uses it Per-source, per-tenant credentials; Key Vault references; rotation
A pipeline’s last modifier Everything that pipeline’s runs read and write Service principal as last modifier, scoped to that pipeline’s workspaces
A shared capacity Availability of every workspace on it, through overload Capacity separation for critical or large tenants
A shared table in pattern A Every tenant’s rows if the filter is bypassed Enforced filtering below the application; move high-risk tenants to C or D

Blast radius should change the architecture, not just the risk register. If the honest answer for a service principal is “all customers’ data”, either that is an accepted, documented risk with compensating controls, or the identity needs to be split.

Security decision framework

Use the same ten steps for each dataset, workload or customer class:

Step Question Output Validation criterion
1. Data classification What is this data, and how sensitive is it? Class and label per dataset Every production dataset has a class and an owner
2. Actors Who and what needs it: people, groups, applications, services, customers? Actor list with purpose No access without a named purpose
3. Access paths Through which engines and interfaces can each actor reach it? Path map per dataset Every path in the map is either controlled or closed
4. Isolation requirement What must stay apart: environments, domains, platform tenants? Isolation pattern per class Pattern documented; cross-tenant tests pass
5. Identity model Which identity performs each operation? Identity per workload, owner per identity No production run depends on a personal account
6. Data-level controls Where does the authoritative rule live, and what do other paths enforce? Control per path Bypass tests through every path fail as expected
7. Network controls What must be private, and how do sources connect? Inbound and outbound design Public access matches policy; sources reachable only as designed
8. Secrets Which credentials exist, and where do they live? Secret inventory, rotation owner No secret in code, definitions or Git
9. Monitoring and audit What evidence will exist, and who watches it? Audit sources, alerts, owners Test events appear in the logs and alerts reach a person
10. Validation How is the design proven, and how often again? Test plan and review cadence Access review and bypass tests scheduled and recorded

Record significant choices as architecture decision records, like any other platform decision, so the reasoning survives the people who made it.

Security architecture review checklist

Use this before approving a production Fabric platform, a new workspace pattern or a new customer class. Every unchecked item is either a decision to make or a risk to accept in writing. For a fuller, printable version to work through in a review meeting, including fill-in tables for access paths, service identities, blast radius and the decision record, use the Data Platform Security Architecture Review Checklist.

Identity

  • Groups, not individuals: workspace roles, item permissions and data roles assigned to groups.
  • Non-human identities identified: every service principal and workspace identity listed with its purpose.
  • Ownership defined: each identity has a named owner team.
  • Rotation and lifecycle: credential expiry, rotation and removal procedures exist and are scheduled.

Workspace

  • Role assignments reviewed: a recurring review, with an owner, for Admin, Member and Contributor.
  • Dev, test and prod separated: separate workspaces, identities, connections and data.
  • Privileged roles minimized: consumers hold Viewer or item permissions only.

Data

  • Every access path identified: semantic model, SQL, Spark, pipelines, OneLake APIs, shortcuts and applications.
  • RLS, OLS and SQL permissions verified: the authoritative rule per dataset is documented.
  • Bypass paths tested: with real identities, through every path a user actually has.

Multi-tenant

  • Isolation pattern documented: per customer class, with the reason.
  • Tenant context propagated: resolved server-side and carried to data and logs.
  • Cross-tenant tests: automated tests prove one tenant can’t read another through each path.
  • Blast radius understood: for each shared identity, table and capacity.
  • Tenant-specific secrets where needed: no credential shared across customers.
  • Cost attribution: consumption attributable per tenant.

Network

  • Public or private requirement: decided and matched by configuration.
  • Gateway design: on-premises and virtual network paths chosen, compatible with Private Link settings.
  • Source connectivity: sources protected by their own firewall rules, not only by Fabric settings.

Secrets

  • No embedded credentials: none in notebooks, pipeline definitions, parameters or Git.
  • Rotation process: tested in non-production before production.

Operations

  • Audit logs: Fabric audit log, OneLake diagnostics and SQL audit enabled where required.
  • Access reviews: scheduled, owned and recorded.
  • Incident owner: a named owner for security incidents on the platform.
  • Tenant-aware logging: tenant ID and executing identity on every relevant log record.

Recovery

  • Revoked identities handled: pipelines and connections don’t break silently, or run on, when a person leaves.
  • Compromised credential response: a rehearsed procedure to rotate, revoke and assess reach.
  • Tenant isolation preserved during restore and replay: reprocessing writes each tenant’s data only to its own targets.

Recommendation

Start with the threat model and the access-path map, not with role assignments. Separate builders from consumers at the workspace level, because builder roles are full data access. Decide where each dataset’s authoritative rule lives and close or align every other path. Choose a multi-tenant isolation pattern per customer class, resolve tenant context on the server and carry it to the data and the logs. Run production work as owned workload identities, keep secrets out of definitions, and treat private networking as a reachability control, not an authorization one. Then measure blast radius honestly and prove the design with bypass tests and access reviews, because a security model that has never been tested through every path is a hypothesis.

Sources

Microsoft-documented behavior in this article comes from these Microsoft Learn pages:

The threat table, identity patterns, workspace-boundary guidance, data-level control comparison, multi-tenant patterns and matrix, tenant isolation controls, blast-radius table, decision framework and review checklist are Javi Builds architectural guidance, not Microsoft documentation. The running example is invented.

Fabric behavior checked against Microsoft Learn in November 2026. Fabric security features change often, and support for workspace private links, outbound access protection and customer-managed keys is tracked per item, with several items in Preview. Recheck the linked pages before relying on a specific behavior or limit.

Tags

  • Microsoft Fabric
  • Data Architecture
  • Multi-Tenancy
  • Fabric Workspace
  • Fabric Warehouse
  • Security