Skip to main content

Azure Service Groups for data platforms: one view across all your subscriptions

· 10 min read
Shpend Kelmendi
Software Engineer & Architect

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.

TL;DR
  • 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 groupsService groupsResource groupsTags
PurposeGovernance hierarchy and policy inheritanceCross-boundary views and data aggregationResource lifecycleMetadata on a resource
MembersSubscriptionsSubscriptions, resource groups, resourcesResources in one subscriptionSingle resources
Multiple membershipNoYesNoYes
Permission inheritanceTo subscriptions and resourcesOnly to child service groupsTo resourcesNone

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 groupMembersAudienceUsed for
Data platformEverything the platform runs onPlatform teamResiliency Agent assessment, health model
Critical path: ingestion to lakeEvent Hubs, Functions, data lake, Key VaultPlatform team, on callSLIs and SLOs, burn rate alerts
ProductionAll production resourcesOperations provider24/7 monitoring with read-only access
Platform teamEverything the team ownsPlatform leadInventory 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 scope
  • Microsoft.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:

  1. 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.
  2. The member API is still moving. I use the preview version 2023-09-01-preview, because that is the one I tested. Since 2026-03-01-preview, and in the non-preview 2026-08-01, the service group moves from targetId to a field called sourceId. Expect that switch when you upgrade, and test it before you do.
  3. Names are global and immutable. A service group ID is unique across all Microsoft Entra tenants and can't be renamed. dataplatform is 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 toUse insteadWhy
Enforce a policy or grant access across many subscriptionsManagement groupsService groups don't pass RBAC or policy to members
Allocate costs per data product or teamTagsNo Cost Management scope for service groups yet
Deploy and delete resources togetherResource groupsService groups don't own the lifecycle
Group a small platform that lives in one subscriptionResource groupsA 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:

ScopeRolePurpose
Service groupSG Drill ContributorCreate, update and run drills
Service groupRecovery Plan ContributorCreate and run recovery plans
Subscription (Chaos workspace)Drill Assets ContributorManage the Automation account and Chaos workspace
Individual resourcesDrill Resource Fault ContributorInject faults into target resources
Subscription (monitoring)Log Analytics Contributor, Monitoring Contributor, User Access AdministratorBuild 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:

  1. 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.
  2. Drills support service groups with up to 500 resources. A large platform group may need splitting.
  3. 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​