Understanding Azure Resource Manager (ARM) with Practical Examples

Introduction

Managing cloud infrastructure manually becomes difficult as applications grow.

Imagine creating:

1. Virtual Machines

2. Databases

3. Storage Accounts

4. Networking

…one by one through the Azure Portal every time.

This is where Azure Resource Manager (ARM) becomes powerful.

ARM allows you to:

• Deploy infrastructure as code

• Automate Azure resource creation

• Manage resources consistently

• Reuse templates across environments

In modern cloud development, ARM is one of the most important concepts for:

1. DevOps

2. CI/CD

3. Infrastructure Automation

4. Cloud Architecture

What is Azure Resource Manager (ARM)?

Azure Resource Manager (ARM) is the deployment and management service for Azure.

It helps you:

• Create

• Update

• Delete

• Organize

Azure resources using:

• Templates

• APIs

• CLI

• PowerShell

ARM Architecture

User / DevOps Engineer
          ↓
 Azure Resource Manager
          ↓
---------------------------------
| VM | Storage | SQL | Network|
---------------------------------

ARM acts as the central management layer between users and Azure resources.

Why ARM is Important

Without ARM:

1. Manual deployments

2. Human errors

3. Difficult scaling

4. Inconsistent environments

With ARM:

• Repeatable deployments

• Automation

• Version-controlled infrastructure

• Faster environment setup

Core ARM Concepts

Resource

A resource is any Azure service.

Examples:

• Virtual Machine

• Storage Account

• SQL Database

• App Service

Resource Group

A logical container for Azure resources.

Example:

• Plain text

• ECommerce-Production-RG

Contains:

• API App Service

• SQL DB

• Storage Account

ARM Template

A JSON file that defines infrastructure.

Infrastructure as Code (IaC)

Example:

• Create VM

• Create Storage

• Configure Networking

• All automatically.

Declarative Syntax

ARM uses declarative configuration.

You define: “What should exist”

Not: “How to create step-by-step”

ARM Template Structure

Basic ARM template:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": []
}

Main Sections Explained

Section	Purpose
$schema	Template schema
contentVersion	Version info
parameters	Input values
variables	Reusable values
resources	Azure resources
outputs	Return values

Practical Example 1: Create Storage Account

ARM Template

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2023-01-01",
      "name": "mystorageaccount123",
      "location": "Central India",
      "sku": {
        "name": "Standard_LRS"
      },
      "kind": "StorageV2",
      "properties": {}
    }
  ]
}

Deploy ARM Template

Using Azure CLI:

az deployment group create \

  --resource-group MyResourceGroup \

  --template-file storage.json

What Happens?

ARM:

• Reads JSON template

• Validates configuration

• Creates storage account

• Ensures desired state

Practical Example 2: App Service + SQL Database

ARM Template

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2022-09-01",
      "name": "my-app-plan",
      "location": "Central India",
      "sku": {
        "name": "B1"
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2022-09-01",
      "name": "my-dotnet-api",
      "location": "Central India",
      "dependsOn": [
   "Microsoft.Web/serverfarms/my-app-plan"
      ],
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', 'my-app-plan')]"
      }
    }
  ]
}

Important Concept: dependsOn

"dependsOn": [
  "Microsoft.Web/serverfarms/my-app-plan"
]

This tells ARM:

• Create App Service Plan first

• Then create Web App

ARM Parameters (Dynamic Templates)

Instead of hardcoding values:
"name": "myapp"

Use parameters:

"parameters": {
  "appName": {
    "type": "string"
  }
}

Then:

"name": "[parameters('appName')]"

Deploy with Parameters

az deployment group create \
  --resource-group MyRG \
  --template-file template.json \
  --parameters appName=myproductionapp

ARM Outputs

Outputs return deployment information.

Example:

"outputs": {
  "websiteUrl": {
    "type": "string",
    "value": "[reference(resourceId('Microsoft.Web/sites', 'my-dotnet-api')).defaultHostName]"
  }
}

Real-World Scenario

Imagine your company has:

• Development

• Staging

• Production

Without ARM: Manual setup every time

With ARM: Same infrastructure everywhere

ARM + CI/CD

ARM templates are heavily used in:

• Azure DevOps

• GitHub Actions

• Example Pipeline Flow

Developer Pushes Code
          ↓
CI/CD Pipeline
          ↓
ARM Template Deployment
          ↓
Infrastructure Created Automatically

ARM vs Bicep

Microsoft introduced Bicep as a simpler alternative.

ARM Example

{
  "type": "Microsoft.Storage/storageAccounts"
}

Bicep Example

resource storage 'Microsoft.Storage/storageAccounts@2023-01-01' = {
  name: 'mystorage'
  location: 'Central India'
}

Bicep is easier to read and write.

When to Use ARM?

Use ARM when:

• Automating infrastructure

• Creating repeatable environments

• Working with DevOps

• Managing production systems

Advantages of ARM

Benefit	Description
Automation	No manual deployment
Consistency	Same infra everywhere
Reusability	Reuse templates
Scalability	Deploy large systems
Version Control	Store templates in Git

Common Challenges

Challenge	Solution
Large JSON files	Use Bicep
Complexity	Modular templates
Debugging	Validate before deployment

Validate ARM Template

az deployment group validate \
  --resource-group MyRG \
  --template-file template.json

Interview Questions

1. What is ARM?

Azure Resource Manager is the deployment and management service for Azure that enables infrastructure automation using templates.

2. What is an ARM Template?

A JSON-based Infrastructure as Code template used to define and deploy Azure resources.

3. ARM vs Classic Deployment?

ARM	Classic
Modern	Legacy
Resource Groups	No Resource Groups
Role-based access	Limited

4. What is dependsOn?

Defines deployment dependency order between resources.

Conclusion

Azure Resource Manager is the foundation of modern Azure infrastructure management.

By learning ARM, you can:

• Automate deployments

• Build scalable systems

• Implement DevOps practices

• Manage enterprise cloud environments efficiently

For cloud engineers and .NET developers, ARM is a critical skill for real-world Azure projects.