Azure Service Groups for data platforms: one view across all your subscriptions
Tom has four browser tabs open. Event Hubs lives in the ingestion subscription. The data lake and the Databricks workspace live in the data subscription. Key Vault and the Azure Functions sit in the shared platform subscription. Private DNS lives in the connectivity hub. All of it is one data platform. There is no place where he sees it as one.
"How do I point the Resiliency Agent at this?" he asks Lena. "It wants an application, not a list of resources."
Lena, a data engineer on the team, doesn't look up. "Which application? The whole platform, or the ingestion path that has to be green by seven every morning?"
Tom stares at her. "Both?"
"That's what service groups are for."
This post explains what Azure Service Groups can do today for a data platform, where their limits are, and how to build them with Terraform. It is the foundation for my next post on resilience management, because the Resiliency Agent works on service groups. Tom and Lena are fictional, the problem is not.
- A data platform rarely fits into one subscription. Service groups group resources, resource groups and subscriptions across subscription boundaries, without touching your existing hierarchy.
- They are views, not governance. No policy and no RBAC flows from a service group to its members.
- Role assignments inherit only to child service groups. A reader on a service group cannot read the data lake inside it.
- One resource can be a member of many service groups. The same data lake can sit in the platform view, the critical-path view and the production view at once.
- Azure Monitor (SLIs, SLOs, health models) and the Resiliency Agent build on service groups. Cost allocation does not, use tags for that.
- You can manage them with Terraform through the AzAPI provider. The identity that adds members needs write access on every member.
- Microsoft lists service groups as public preview as of October 2026.
Why data platforms need this
A typical Azure data platform is spread out by design:
- Ingestion: Event Hubs, Azure Functions
- Storage and compute: Azure Data Lake Storage Gen2, Azure Databricks
- Shared services: Key Vault, Log Analytics, the Unity Catalog metastore
- Networking: private endpoints and Private DNS zones in a connectivity hub
That split makes sense for governance and network isolation. It makes no sense for the questions people actually ask. "Is ingestion healthy right now?" "What breaks if a zone goes down?" "What does the operations provider need to see at 3 a.m.?" None of these questions follows subscription boundaries.
Until now the answer was a resource graph query, a naming convention or a tag. Service groups add a first-class grouping for exactly this.
What service groups are
A service group is a custom grouping of Azure resources. Members can be subscriptions, resource groups or single resources, from anywhere in the same tenant.
Your existing hierarchy stays as it is. Management groups, subscriptions and resource groups don't move. Service groups sit next to them, created at tenant level under a single root service group.
In short: a service group is a virtual folder for one perspective on your data platform.
Views, not governance
"So it's another governance layer?" Tom asks.
"No," says Lena. "Governance means setting rules and enforcing them."
That is the definition I use:
- Who may do what: Azure RBAC
- What is allowed: Azure Policy
- How much may be spent: budgets and cost controls
The key word is enforce. Management groups enforce. A policy or role assignment on a management group flows down to every subscription and resource below it. Service groups don't enforce anything on their members. They show and aggregate.
| Management groups | Service groups | Resource groups | Tags | |
|---|---|---|---|---|
| Purpose | Governance hierarchy and policy inheritance | Cross-boundary views and data aggregation | Resource lifecycle | Metadata on a resource |
| Members | Subscriptions | Subscriptions, resource groups, resources | Resources in one subscription | Single resources |
| Multiple membership | No | Yes | No | Yes |
| Permission inheritance | To subscriptions and resources | Only to child service groups | To resources | None |
Hierarchy and inheritance
Tom wants structure, so he nests. One group for the whole data platform, with a child group for each part: ingestion and analytics. Every service group has exactly one parent, set through the parent property. The root service group sits at the top and carries the tenant ID as its ID. You can nest up to 10 levels deep.
Then the surprise. Tom gives the operations provider the Service Group Reader role on the data platform group and expects them to see the data lake. They see the group, the ingestion and analytics groups and the member relationships. They can't open the storage account.
The rule behind it:
- A role assignment on a service group inherits to all child service groups.
- It does not inherit to the members. Access to the resources still comes from management groups, subscriptions and resource groups.
Solid lines are the hierarchy, and roles follow them. Dotted lines only mean "is a member of" and grant nothing. The data lake sits in both child groups, because ingestion writes to it and analytics reads from it.
One more detail for planning. The monitoring view of a service group shows only its direct members. Insights from child service groups are not rolled up. If the data platform group has only child groups and no members of its own, its monitoring page stays empty. Put members where you want to see them together.
Parallel views
This is where service groups pay off for data platforms. The hierarchy above is one view. Nothing stops Tom from building others over the same resources, because membership is not exclusive. He ends up with four, each with its own audience and job:
| Service group | Members | Audience | Used for |
|---|---|---|---|
| Data platform | Everything the platform runs on | Platform team | Resiliency Agent assessment, health model |
| Critical path: ingestion to lake | Event Hubs, Functions, data lake, Key Vault | Platform team, on call | SLIs and SLOs, burn rate alerts |
| Production | All production resources | Operations provider | 24/7 monitoring with read-only access |
| Platform team | Everything the team owns | Platform lead | Inventory and ownership |
The data lake is a member of all four. In a governance hierarchy that is impossible, because everything has exactly one parent.
Microsoft doesn't publish formal design guidance yet. The docs and the community use the same three patterns Tom ended up with: by workload, by owner and by environment. I would add a fourth for data platforms: the critical path, because that is where an SLO is most useful.
The roles
Service groups have three built-in Azure RBAC roles. They are not Microsoft Entra ID roles. You assign them at the scope of a service group.
- Service Group Administrator: manages everything, including role assignments for the three service group roles. Whoever creates a service group gets this role.
- Service Group Contributor: manages groups and memberships, but can't assign roles.
- Service Group Reader: reads service groups and their member relationships.
Custom roles aren't supported during the preview.
When Tom tries to add the data lake, Contributor on the group isn't enough. Membership is stored on the member, as a service group member relationship. So he also needs Microsoft.Relationships/serviceGroupMember/write on the storage account itself. That is deliberate. Nobody can pull the platform team's resources into their view without write access to them.
Access to the root service group is special. It requires roleAssignments/write at tenant level, for example a Global Administrator who elevates their access.
Service groups with Terraform
The Azure portal works fine for a first try. A platform team wants the groups in code, next to the platform itself. Two resource types are involved:
Microsoft.Management/serviceGroups: the group, deployed at tenant scopeMicrosoft.Relationships/serviceGroupMember: the membership, deployed as an extension on the member (a subscription, resource group or resource)
The azurerm provider has no service group resource yet, so I use azapi. I tested this pattern with Terraform 1.15 and azapi 2.13 in October 2026.
terraform {
required_providers {
azapi = {
source = "Azure/azapi"
version = "~> 2.5"
}
}
}
variable "tenant_id" {
type = string
}
variable "prefix" {
type = string
description = "Service group IDs are unique across all tenants, so prefix them with something that is yours"
}
# Resource IDs of the ingestion members, for example the resource groups
# that hold Event Hubs and the data lake
variable "ingestion_member_ids" {
type = map(string)
}
# Parent group for the whole data platform, directly under the root service group
resource "azapi_resource" "sg_data_platform" {
type = "Microsoft.Management/serviceGroups@2026-08-01"
name = "${var.prefix}-dataplatform" # immutable after creation
parent_id = "/" # tenant scope
body = {
properties = {
displayName = "Data platform"
parent = { resourceId = "/providers/Microsoft.Management/serviceGroups/${var.tenant_id}" }
}
}
}
# Child group for the ingestion path
resource "azapi_resource" "sg_ingestion" {
type = "Microsoft.Management/serviceGroups@2026-08-01"
name = "${var.prefix}-dataplatform-ingestion"
parent_id = "/"
body = {
properties = {
displayName = "Ingestion"
parent = { resourceId = azapi_resource.sg_data_platform.id }
}
}
}
# Membership lives on the member, so parent_id is the member's resource ID
resource "azapi_resource" "ingestion_members" {
for_each = var.ingestion_member_ids
type = "Microsoft.Relationships/serviceGroupMember@2023-09-01-preview"
name = "sgm-ingestion-${each.key}"
parent_id = each.value
body = {
properties = {
targetId = azapi_resource.sg_ingestion.id
targetTenant = var.tenant_id
}
}
}
Three things matter more than the code itself:
- The deploying identity needs write access on every member. Membership is created where the member lives, not on the service group. A pipeline that only has rights on the service group fails as soon as it adds the first member. In a platform with separate Terraform states per subscription, it is often simpler to declare the membership in the state that already owns the resource.
- The member API is still moving. I use the preview version
2023-09-01-preview, because that is the one I tested. Since2026-03-01-preview, and in the non-preview2026-08-01, the service group moves fromtargetIdto a field calledsourceId. Expect that switch when you upgrade, and test it before you do. - Names are global and immutable. A service group ID is unique across all Microsoft Entra tenants and can't be renamed.
dataplatformis almost certainly taken.
If you prefer a module, there is an Azure Verified Module (AVM): terraform-azurerm-avm-res-management-servicegroup.
From API version 2026-08-01 a service group can also carry a criticality value from 0 to 4. If your data platform has tiers, that is a natural place to record them. One caveat from my test: setting criticality through ARM did not automatically give the service group a resilience goal, although the docs suggest it would. More on that in the next post.
What Tom uses them for
Monitoring. Each service group has a monitoring page in the Azure portal with issues, an application map, availability tests and service level indicators. You can define SLIs and SLOs per service group, with error budgets and burn rate alerts. If you read my post on SLI, SLO and SLA, the critical-path group is where those numbers belong. Azure Monitor health models can also discover their entities from a service group.
Resilience. The Resiliency Agent in Azure Copilot doesn't work on a flat list of resources. It works on your application, represented as a service group. For a data platform that raises a real design question: do you assess the whole platform or only the critical path? I'll answer that in the next post.
Costs. This is the gap. I could not find service groups as a scope in Cost Management. For cost per data product or team, tags are still the tool. My tagging series shows how.
Practical case: 24/7 operations
A service provider is asked to monitor the data platform around the clock. Tom separates two things:
- Permanent: Service Group Reader on the production group, plus Monitoring Reader on the Log Analytics workspace. Enough to watch the state and follow alerts.
- On demand: To rerun a failed ingestion, restore a storage container or fail over a database, the on-call engineer activates the right role on the resource group or subscription through Privileged Identity Management (PIM). Time-limited and logged.
"The service group gives you eyes," Lena says. "Not hands."
Would I run a 24/7 setup like this? Yes, but it is a trade-off. Service Group Reader covers the daily work: watching the state, following alerts, opening tickets. The PIM roles cover the rare moments when someone has to act. I would make them time-limited and logged, with a justification on every activation, but without an approval step. At 3 a.m. nobody is awake to approve, and an engineer who waits for an approval while ingestion is down is the bigger risk. The justification and the log give you the control afterward.
When service groups are the wrong tool
Service groups solve one problem well. They are not the answer to every grouping question:
| You want to | Use instead | Why |
|---|---|---|
| Enforce a policy or grant access across many subscriptions | Management groups | Service groups don't pass RBAC or policy to members |
| Allocate costs per data product or team | Tags | No Cost Management scope for service groups yet |
| Deploy and delete resources together | Resource groups | Service groups don't own the lifecycle |
| Group a small platform that lives in one subscription | Resource groups | A service group adds a layer without adding a view |
If your data platform fits into one subscription and one team owns all of it, you probably don't need service groups yet. The moment a second subscription, a domain team or an operations provider shows up, you do.
What this means for resilience
How strictly views and resource access are separated shows in the roles for zone down drills in Azure Infrastructure Resiliency Manager:
| Scope | Role | Purpose |
|---|---|---|
| Service group | SG Drill Contributor | Create, update and run drills |
| Service group | Recovery Plan Contributor | Create and run recovery plans |
| Subscription (Chaos workspace) | Drill Assets Contributor | Manage the Automation account and Chaos workspace |
| Individual resources | Drill Resource Fault Contributor | Inject faults into target resources |
| Subscription (monitoring) | Log Analytics Contributor, Monitoring Contributor, User Access Administrator | Build monitoring and assign roles |
The service group is enough to plan a drill. Breaking something needs rights on the resources. User Access Administrator belongs in PIM, not in a permanent assignment.
Three limits apply:
- Service groups, the Azure Monitor experience and the Resiliency Agent are all in public preview. A non-preview API version (
2026-08-01) exists, but Microsoft Learn still labels the service as preview. - Drills support service groups with up to 500 resources. A large platform group may need splitting.
- Azure Site Recovery and multi-user authorization still need manual steps in the agent.
Lessons learned
A data platform is shaped by governance and networking. The people who run and use it think in paths, owners and audiences. Service groups close that gap without forcing you to reorganize subscriptions. The mental model that helped me most: management groups decide what may happen, service groups decide what you see together.
Tom's groups stand: one for the platform, one for the critical path, one for production. In the next post he points the Resiliency Agent at them, from the first assessment to the first drill.
Sources
- What are Azure Service Groups?
- Quickstart: Create a service group with REST API
- Quickstart: Add members to service groups
- Template reference: Microsoft.Management serviceGroups
- Template reference: Microsoft.Relationships serviceGroupMember
- Azure built-in roles for management and governance
- Monitoring Service Groups with Azure Monitor (preview)
- Health models in Azure Monitor
- Support matrix for availability zone down drills
- Azure Copilot Resiliency Agent (preview)

