Executive summary
Azure Arc is a management platform that projects on‑premises, multi‑cloud, and edge resources into Azure Resource Manager so they can be governed with Azure tools. By using Arc, organizations can create consistent landing zones, apply Azure‑native identity, and standardize services such as Azure Policy, Azure Monitor, and Microsoft Defender for Cloud across the entire estate. This deep dive explains the technical fundamentals, architecture, implementation steps, security considerations, and operational best practices for platform teams that need to manage infrastructure across datacentres, edge sites, and Azure. The goal is to give a comprehensive view that helps decision makers understand how Arc can reduce operational friction while extending Azure‑first capabilities to any environment.
Introduction
Hybrid and multi‑cloud environments have become the norm as enterprises seek to keep latency‑sensitive workloads close to users, preserve existing investments, and avoid vendor lock‑in. Microsoft Azure provides a set of hybrid capabilities, but the management experience has historically been fragmented: on‑premises tools for Windows Server, separate consoles for VMware, distinct processes for Kubernetes, and yet another workflow for Azure‑hosted services. Azure Arc unifies these silos by projecting any supported resource—Windows or Linux servers, VMware virtual machines, Kubernetes clusters, and Azure data services—into Azure Resource Manager (ARM). Once projected, the resources appear alongside native Azure resources in the portal, Azure CLI, PowerShell, and REST APIs.
The platform team’s role is to define landing zones, identity models, and a catalog of services that every projected resource must consume. Landing zones provide a repeatable set of policies, network configurations, and governance controls that ensure compliance and operational consistency. Identity, typically Azure Active Directory (AAD), enables role‑based access control (RBAC) across the whole estate. Standardized services such as Azure Policy, Azure Monitor, and Microsoft Defender for Cloud deliver security, compliance, and observability regardless of where the workload runs. By treating on‑premises and edge resources as first‑class Azure objects, organizations can apply a single set of DevOps pipelines, CI/CD tooling, and IaC templates across the full estate.
Technical fundamentals
Azure Arc delivers five outcomes as described in the official overview:
- A single inventory of all resources, regardless of location, by projecting them into ARM.
- Management of virtual machines, Kubernetes clusters, and databases as if they were native Azure resources.
- Ability to consume Azure services (for example, Azure Monitor, Defender) on any resource.
- A migration path from traditional IT operations toward DevOps practices.
- Custom locations that abstract Arc‑enabled Kubernetes clusters for workloads such as Azure Container Apps and Azure Arc‑enabled data services.
Key technical concepts include:
- Arc‑enabled servers – Windows or Linux machines that run a connected‑machine agent. The agent reports inventory and enables Azure extensions (monitoring, security, updates).
- Arc‑enabled Kubernetes – Any supported Kubernetes distribution that registers with Azure Arc, exposing the cluster to Azure Policy, Azure Monitor, and GitOps via Flux.
- Arc‑enabled data services – Azure SQL Managed Instance or PostgreSQL that run on customer‑managed Kubernetes, receiving Azure‑level updates and scaling.
- Resource bridge – A pre‑packaged virtual appliance that runs as a Kubernetes‑based management cluster in private clouds (VMware vSphere, SCVMM, Azure Local). The bridge projects on‑premises resources into ARM but is distinct from the connected‑machine agent.
- Custom locations – Logical targets that represent Arc‑enabled Kubernetes clusters, allowing Azure services to be deployed to them.
All control‑plane features (management groups, tags, Azure RBAC, Azure Resource Graph, ARM templates) are offered at no extra cost. Consumption‑based services such as Microsoft Defender for Cloud and Azure Monitor are billed per their own pricing models, which means the governance layer remains free while the value‑added services are charged based on usage.
Architecture and components
The hybrid architecture positions Azure Arc as the unified control plane. Figure 1 illustrates the data flow.
+-----------------+ +-------------------+ +--------------------+
| Datacentre | | Edge Site | | Other Cloud (AWS) |
| (VMware, SCVMM)| | (IoT Gateways) | | (VMs, K8s) |
+--------+--------+ +--------+----------+ +----------+---------+
| | |
| Resource Bridge | Connected‑machine | Connected‑machine
| (VMware/SCVMM) | agent (servers) | agent (servers)
v v v
+---------------------------------------------------------------+
| Azure Resource Manager (ARM) |
| - Management groups, tags, RBAC, Policy, Monitor, Defender |
+-------------------+-------------------+-----------------------+
| |
v v
+----------------+ +-------------------+
| Arc‑enabled | | Arc‑enabled |
| Kubernetes | | Data Services |
+----------------+ +-------------------+
Figure 1: Hybrid sites connect upward to Azure Resource Manager through Arc. The resource bridge appears only on the private‑cloud VM path.
| Component | Projected into ARM | Runs locally | Primary purpose |
|---|
| Arc‑enabled servers | Yes | Agent only | Inventory, extensions |
| Arc‑enabled Kubernetes | Yes | Control plane stays on‑prem | Cluster governance, GitOps |
| Arc‑enabled data services | Yes | Pods on customer K8s | Managed database service |
| Resource bridge | Yes (VMware/SCVMM) | Management cluster | Conduit for projection |
Detailed implementation approach
The implementation follows a repeatable sequence that aligns with the guidance in the official documentation. Each phase is designed to be automated where possible, allowing platform teams to scale onboarding across hundreds or thousands of assets.
- Select the Arc service – Identify whether the target is a server, a Kubernetes cluster, or a data service. The decision is based on workload type, operating‑system compatibility, and existing infrastructure ownership.
- Prepare networking – Ensure outbound HTTPS connectivity to Azure Arc endpoints (Azure public cloud) and configure any required proxy settings. For private‑cloud deployments, the resource bridge must have a virtual network that can reach the Azure backbone without traversing NAT that blocks required ports.
- Deploy the appropriate agent –
- Servers – Install the connected‑machine agent on each Windows or Linux host using PowerShell, Bash, or a software‑distribution tool such as SCCM or Ansible. The agent registers the machine, creates a virtual resource in ARM, and begins sending heartbeat messages.
- Kubernetes – Run the Arc onboarding script (
az connectedk8s connect) which creates the azure-arc namespace, installs the Azure Arc extension, and registers the cluster with Azure. The script also configures the cluster for Azure Policy and monitoring extensions.
- Data services – Provision the Azure Arc‑enabled SQL Managed Instance or PostgreSQL on an existing Arc‑enabled Kubernetes cluster. This step creates the data‑service resource in ARM and deploys the required containers.
- Create a custom location (optional) – If you plan to host Azure Container Apps or other Azure services on the cluster, define a custom location that points to the Arc‑enabled Kubernetes cluster. This logical construct allows Azure to treat the cluster as a target region for service deployment.
- Apply Azure RBAC and tags – Use Azure Resource Graph or ARM templates to assign role‑based access and organizational tags at the resource or resource‑group level. Tags are essential for cost allocation and governance reporting.
- Enforce Azure Policy – Deploy built‑in or custom policies for compliance, for example requiring the Azure Monitor agent on every server, restricting VM sizes, or mandating encryption at rest. Policies are evaluated continuously and non‑compliant resources appear in the compliance dashboard.
- Enable monitoring and security – Attach Microsoft Defender for Cloud and Azure Monitor extensions to servers or clusters. Data services automatically inherit monitoring agents, providing a unified observability pane.
- Adopt GitOps (Kubernetes only) – Configure Flux through the Azure Arc GitOps connector to pull declarative configurations from a Git repository. This ensures the cluster state converges to the desired manifest stored in source control, reducing drift.
Each step is documented in the Microsoft guides and does not require custom scripts beyond the officially supplied onboarding commands. Automation can be achieved with Azure CLI, PowerShell, or ARM/Bicep templates, enabling bulk onboarding and repeatable landing‑zone deployment.
Architecture and data‑flow
Once resources are projected, they become part of the Azure resource graph. Azure RBAC evaluates the caller’s permissions against the resource’s Azure AD identity. Azure Policy evaluates compliance rules in real time, generating compliance reports that are visible in the portal. Azure Monitor collects telemetry via the installed agents and forwards it to Log Analytics workspaces. Defender for Cloud continuously assesses security posture and can trigger auto‑remediation.
The data‑flow can be summarized as follows:
- Discovery – The agent or bridge discovers local inventory and sends a JSON payload to Azure Arc’s control plane.
- Projection – Azure creates a virtual ARM resource that represents the physical or virtual asset.
- Control – Azure RBAC and Policy act on the projected resource just like any native Azure resource.
- Telemetry – Agents forward logs, metrics, and security findings to Azure Monitor and Defender.
- Action – Platform teams can invoke ARM templates, Terraform, or Bicep scripts to manage lifecycle (create, resize, delete) across all locations.
Because the control plane lives in Azure, policy changes propagate globally without needing to patch each on‑premises system individually. Telemetry ingestion remains near‑real‑time as long as the outbound connectivity is healthy, allowing operational teams to build alerting and dashboarding experiences that span datacentres, edge, and public‑cloud workloads.
Security and governance
Azure Arc inherits Azure’s security model. Key controls include:
- Azure AD authentication – All management operations require an Azure AD token. Service principals can be scoped to specific resource groups or custom locations, enabling automation with least‑privilege credentials.
- RBAC – Role assignments are applied at the management group, subscription, resource group, or individual resource level. The same RBAC model governs on‑premises servers, Kubernetes clusters, and data services, simplifying permission management.
- Azure Policy – Policies can enforce required extensions (for example, Azure Monitor agent), restrict VM sizes, or require encryption. Policy evaluation runs in Azure and reports compliance status back to the projected resource, allowing centralized compliance dashboards.
- Microsoft Defender for Cloud – When enabled on Arc‑enabled servers or clusters, Defender provides threat detection, vulnerability assessments, and secure score calculations. Billing follows the standard Defender pricing model.
- Network security – Outbound connections from agents to Azure are encrypted with TLS. In‑bound traffic follows the customer’s existing firewall rules; no inbound ports are opened by Arc, which reduces the attack surface.
The retired “indirectly connected” mode should not be used; it was discontinued in September 2025. All deployments must use the directly connected approach to ensure full policy evaluation and telemetry flow.
Enterprise use cases
| Use case | How Azure Arc is applied |
|---|
| Datacenter consolidation | Project existing VMware VMs into ARM, apply unified tagging and policy, and enable self‑service VM lifecycle through Azure RBAC. |
| Edge analytics | Deploy Arc‑enabled Kubernetes on an edge gateway, register a custom location, and run Azure Container Apps for low‑latency processing while still receiving Azure Monitor insights. |
| Multi‑cloud compliance | Register Azure‑hosted VMs, AWS EC2 instances, and on‑premises servers under a single Azure Policy set to enforce encryption and patching. |
| Hybrid database modernization | Run Azure SQL Managed Instance on customer‑owned Kubernetes, benefiting from Azure‑level patching and scaling without moving data to Azure. |
These scenarios illustrate how a single governance plane can reduce operational overhead, enforce compliance across disparate environments, and unlock Azure services at the edge.
Benefits and limitations
Benefits
- Single pane of glass for inventory and governance.
- Consistent identity and RBAC across all environments.
- Ability to consume Azure services locally, reducing latency for edge workloads.
- No need to re‑architect workloads to run in Azure; existing investments remain intact.
- Enables a DevOps workflow through GitOps on Kubernetes, aligning with modern CI/CD practices.
Limitations
- The resource bridge is required only for private‑cloud VM projection; it adds a management cluster that must be maintained and patched.
- Not all Azure services are available on every resource type; for example, Azure Functions run only on Azure or on Arc‑enabled Kubernetes via Container Apps.
- Network connectivity to Azure must be reliable; intermittent connectivity can delay policy evaluation and telemetry ingestion.
- Indirectly connected mode is no longer supported, so all deployments must use the directly connected approach.
Understanding these trade‑offs helps architects decide where Arc adds value and where additional tooling may be required.
Operational considerations
- Monitoring health of agents – Use Azure Monitor alerts to detect missing heartbeats from connected‑machine agents. A missing heartbeat indicates connectivity loss or agent failure and should trigger an automated remediation runbook.
- Patch management – Azure Update Management extensions can be applied to Arc‑enabled servers, but patch cadence must be coordinated with on‑premises change‑control processes to avoid conflicts with existing maintenance windows.
- Backup and disaster recovery – Azure Arc does not provide backup; customers must use existing backup solutions for on‑premises assets. However, Azure Monitor and Defender data are retained according to the workspace retention settings.
- Scaling the resource bridge – The bridge runs as a Kubernetes cluster; capacity planning should consider the number of projected VMs, the frequency of inventory syncs, and the volume of telemetry. Monitoring the bridge’s own resource usage is essential to avoid bottlenecks.
- Cost governance – Since Azure services are billed per usage, enable cost‑center tagging and use Azure Cost Management to track consumption of Defender, Monitor, and data services. This practice prevents unexpected spend when scaling Arc across many edge sites.
Best practices
- Define landing zones early – Create Azure Policy initiatives that cover required tags, allowed VM sizes, and mandatory extensions. Apply these initiatives at the management‑group level so new resources inherit them automatically.
- Use Azure AD groups for RBAC – Assign roles to groups rather than individual users to simplify permission management and to align with corporate identity governance.
- Separate environments with management groups – Production, test, and development can each have their own management‑group hierarchy, allowing distinct policy sets and cost‑allocation structures.
- Automate onboarding – Use PowerShell or Azure CLI scripts to bulk install the connected‑machine agent on servers and register Kubernetes clusters. Include health‑check steps that verify successful projection before proceeding.
- Leverage GitOps for Kubernetes – Store desired state in Git and let Flux continuously reconcile the cluster, reducing drift and providing an audit trail of configuration changes.
- Regularly review compliance reports – Azure Policy compliance dashboards highlight non‑conforming resources; remediate promptly to maintain security posture.
- Document the resource bridge topology – Keep an inventory of bridge clusters, their versions, and the private clouds they serve. Version‑control this documentation to aid troubleshooting and upgrade planning.
- Validate network paths – Perform periodic connectivity tests from agents to Azure Arc endpoints to ensure outbound traffic is not blocked by firewall changes.
- Plan for agent upgrades – Schedule rolling upgrades of the connected‑machine agent using automation tools to avoid simultaneous downtime across large fleets.
Analysis
The sources clearly describe Azure Arc’s ability to project resources, the role of the resource bridge, and the governance model. However, the documentation does not provide quantitative performance metrics for the bridge or guidance on optimal sizing for large inventories. Platform teams must therefore conduct their own load testing when scaling to tens of thousands of projected objects. Additionally, while Azure Policy and Defender provide powerful compliance capabilities, the latency between a policy change and its enforcement on a remote cluster is not quantified, leaving a potential gap in time‑critical security scenarios.
What the sources do not settle
- Latency of policy enforcement – While Azure Policy is applied centrally, the exact time from a policy change to enforcement on a remote cluster is not quantified.
- Agent upgrade path – The documentation outlines how to install agents but does not detail the process for rolling upgrades across heterogeneous OS versions.
- Hybrid cost modeling – Pricing pages are referenced for service‑specific costs, but there is no unified cost model that includes bridge infrastructure and management overhead.
These open questions suggest areas for future guidance from Microsoft or for internal proof‑of‑concept testing before large‑scale adoption.
Conclusion
Azure Arc provides a cohesive framework for managing heterogeneous infrastructure as if it were native Azure. By projecting servers, Kubernetes clusters, and data services into Azure Resource Manager, organizations gain a single inventory, unified identity, and consistent governance. Landing zones, Azure AD‑based RBAC, and standardized services such as Azure Policy, Azure Monitor, and Microsoft Defender for Cloud form the foundation of a secure and observable hybrid estate. While the platform introduces new components like the resource bridge and requires reliable network connectivity, the benefits of reduced operational complexity and the ability to extend Azure services to edge and on‑premises workloads are compelling for enterprises pursuing a true hybrid cloud strategy.
References
These published CloudExchangers articles are further desk reading. They are not sources for the technical claims above.