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.
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.
- Customer orders tableDelta table in OneLake
- DAXModel RLS / OLSSemantic modelApplies to Viewers only, not to builders
- T-SQLSQL or OneLake rulesSQL endpoint or WarehouseDepends on the item and the endpoint's access mode
- SparkOneLake securityNotebook / SparkBuilders read everything in the workspace
- service runRun identityPipeline or jobRuns as the pipeline's last modifier or a connection
- ADLS APIOneLake securityOneLake APIAlso needs the external-apps tenant setting
- shortcutPassthrough or delegatedShortcut elsewhereUser identity or the connection's credential
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.
Identity
- People in groupsEntra ID, Conditional Access
- Workload identitiesService principals, workspace identity
Network
- InboundTenant or workspace private links
- OutboundGateways, managed private endpoints, OAP
Workspace
- BuildersAdmin, Member, Contributor: full data access
- ConsumersViewer: subject to data rules
Item
- Item permissionsRead, ReadData, ReadAll, Build, Reshare
- Shortcuts and sharesPassthrough, delegated, external
Data
- OneLake securityTables, folders, RLS, CLS
- SQL permissionsGRANT, RLS, CLS, masking
- Model securityRLS, OLS for report readers
Consumer
- Reports
- Applications and APIs
- Notebooks and SQL clients
Cross-cutting concerns
- Governance
- Secrets
- Audit
- Tenant context
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:
- 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.
- 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.
- 1Isolation · low–mediumShared storeTenant ID column in shared tables; lowest cost
- 2Isolation · mediumSchema-separatedSchema or folder per tenant in shared items
- 3Isolation · highWorkspace per tenantRoles, items and lifecycle per customer
- 4Isolation · very highDedicatedOwn workspace, store and capacity; highest cost
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:
- 1User or applicationSigns in; may request a customer
- 2IdentityEntra token proves who is calling
- 3Tenant authorizationTrusted mapping decides which tenants are allowed
- 4Query or pipelineTenant predicate, schema or workspace applied
- 5DataEnforced filter or isolated store returns one tenant
- 6Audit and loggingTenant, identity and operation recorded together
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.
What to read next
- Fabric Security Lab: Workspace Roles, Data Access, RLS and Masking: the hands-on companion to this guide. Test workspace roles, item permissions, Warehouse RLS, CLS and masking, and OneLake folder roles as a second user, including the paths each control doesn’t cover.
- Designing a Production Data Platform: where security sits among the platform’s other architecture decisions.
- Microsoft Fabric Governance with Microsoft Purview: domains, labels, lineage, endorsement and the governance operating model.
- Building a Multi-Tenant Report Engine: enforcing tenant scope in the application layer.
- How to Secure SQL Endpoints in Azure: private network paths to SQL and Fabric TDS endpoints.
- SQL Server to Microsoft Fabric: What Maps to What?: why workspaces and roles are not databases and logins.
- Microsoft Fabric CI/CD with fabric-cicd: deploying with a service principal and parameterized environments.
Sources
Microsoft-documented behavior in this article comes from these Microsoft Learn pages:
- Platform security and identity: Security in Microsoft Fabric, Workspace identity, Authenticate with workspace identity, Trusted workspace access, Workspace customer-managed keys
- Workspace and item permissions: Roles in workspaces, Share items
- OneLake security: Data security overview, OneLake security roles, permissions and scopes (role union, limits, shortcuts, latencies), OneLake security for SQL analytics endpoints (user identity and delegated modes, Warehouse security through shortcuts), OneLake shortcuts
- Warehouse and semantic models: Secure your Fabric Data Warehouse, Row-level security with Power BI (Viewer-only enforcement, service principals, B2B guests, embedded effective identity)
- Service identities: How to use notebooks: security context (interactive, pipeline and scheduled run identities), Notebook activity, Set a service principal as pipeline owner
- Secrets: Configure Azure Key Vault references
- Networking: Private links for Fabric, Workspace-level private links, Workspace outbound access protection, Security feature availability (GA and Preview status by item)
- Sharing across tenants: External data sharing
- Governance and auditing: Governance and compliance in Microsoft Fabric, Information protection in Microsoft Fabric, Track user activities, OneLake diagnostics
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.
Was this helpful?
What could be better?
Thanks — that helps me improve Javi Builds.
Continue learning
- Cheat sheetLakehouse vs WarehouseChoose between Microsoft Fabric Lakehouse and Warehouse by comparing development model, data types, SQL capabilities, transactions, ingestion patterns, and downstream analytics requirements.Open cheat sheet
- ResourceData Platform Security Architecture Review ChecklistThe security architecture questions to verify before approving a production data platform, for single-organization and multi-tenant platforms alike.View resource
What should I build next?
I'm building Javi Builds around practical problems data engineers actually face. Tell me what you'd like to see next.
Stay in the loop
Get the Javi Builds updates you actually care about.
Check your inbox
I sent you a confirmation link. Your subscription will be active after you confirm it.