# Advanced Azure Quota Commands

Reference for less commonly used Azure quota CLI commands for tracking quota requests and operations.

## az quota request status list

Get current quota requests for a one-year period. Use oData filter to select requests.

**Syntax**:
```bash
az quota request status list --scope SCOPE [--filter FILTER] [--max-items N] [--next-token TOKEN] [--skip-token TOKEN] [--top N]
```

**Required**:
- `--scope` - Target Azure resource URI

**Optional**:
- `--filter` - Filter by requestSubmitTime (ge/le/eq), provisioningState (eq), resourceName (eq)
- `--max-items` - Total items to return
- `--next-token` - Pagination token from previous response
- `--skip-token` - Skip token for next page
- `--top` - Number of records to return

**Examples**:
```bash
# List compute quota requests
az quota request status list --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus

# List network quota requests
az quota request status list --scope /subscriptions/{id}/providers/Microsoft.Network/locations/eastus
```

## az quota request status show

Get quota request details and status by request ID. The ID is returned from `az quota update` PUT operation.

**Syntax**:
```bash
az quota request status show --id REQUEST_ID --scope SCOPE
```

**Required**:
- `--id` - Quota request ID
- `--scope` - Target Azure resource URI

**Example**:
```bash
az quota request status show \
  --id 2B5C8515-37D8-4B6A-879B-CD641A2CF605 \
  --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus
```

## az quota operation list

List all operations supported by Microsoft.Quota resource provider.

**Syntax**:
```bash
az quota operation list
```

**Examples**:
```bash
# List all operations
az quota operation list

# Table format
az quota operation list --output table
```

# Azure Quota CLI Commands Reference

Comprehensive reference for Azure CLI quota commands.

## Prerequisites

**Install quota extension** (required):
```bash
az extension add --name quota
```

> **⚠️ CRITICAL: ALWAYS USE CLI FIRST**
>
> Azure CLI is the **ONLY reliable method** for quota checks. **Use `az quota` commands FIRST, always.**
>
> **DO NOT use REST API or Azure Portal as your first approach.** They are unreliable.
>
> **Required workflow:**
> 1. **FIRST:** Try `az quota list` / `az quota show` / `az quota usage show`
> 2. **If CLI returns `BadRequest`:** Resource provider doesn't support quota API → use [Azure service limits docs](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/azure-subscription-service-limits)
> 3. **Never start with REST API or Portal** - only use as fallback
>
> **Why REST API/Portal are unreliable:**
> - REST API returns "No Limit" or "Unlimited" values that are **MISLEADING**
> - "No Limit" **DOES NOT mean unlimited capacity** - usually means resource doesn't support quota API
> - Service-specific limits still apply even when REST API shows "No Limit"
> - Portal may show incomplete or cached quota data
> - REST API lacks proper error handling for unsupported providers
>
> **If you see "No Limit" in REST API/Portal:**
> - ❌ This is NOT unlimited capacity
> - ✅ It means quota API doesn't support that resource type
> - ✅ Check [Azure service limits docs](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/azure-subscription-service-limits) for actual limits
> - ✅ Regional capacity constraints may still exist

## Resource Name Mapping

**⚠️ CRITICAL:** No 1:1 mapping exists between ARM resource types and quota names. Always discover via `az quota list`.

**Discovery workflow**:
1. List all quotas: `az quota list --scope /subscriptions/{id}/providers/{Provider}/locations/{region}`
2. Match `properties.name.localizedValue` to your resource type
3. Use exact `name` value in subsequent commands

**Example mappings**:

| ARM Type | Quota Name |
|----------|-----------|
| `Microsoft.App/managedEnvironments` | `ManagedEnvironmentCount` |
| `Microsoft.Compute/virtualMachines` | `standardDSv3Family`, `cores`, `virtualMachines` |
| `Microsoft.Network/publicIPAddresses` | `PublicIPAddresses`, `IPv4StandardSkuPublicIpAddresses` |

## Command Summary

| Command | Description |
|---------|-------------|
| [az quota list](#az-quota-list) | List all quota limits for a scope |
| [az quota show](#az-quota-show) | Show quota limit for specific resource |
| [az quota usage list](#az-quota-usage-list) | List current usage for all resources |
| [az quota usage show](#az-quota-usage-show) | Show current usage for specific resource |
| [az quota update](#az-quota-update) | Request quota increase |
| [az quota create](#az-quota-create) | Create quota limit (advanced) |

See [advanced-commands.md](advanced-commands.md) for request status and operation commands.

---

## az quota list

List all quota limits for a scope. **Use this first to discover quota resource names.**

**Syntax**:
```bash
az quota list --scope SCOPE [--max-items N] [--next-token TOKEN]
```

**Required**:
- `--scope` - Azure resource URI: `/subscriptions/{id}/providers/{Provider}/locations/{region}`

**Examples**:
```bash
# List compute quotas
az quota list --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus

# List network quotas
az quota list --scope /subscriptions/{id}/providers/Microsoft.Network/locations/eastus

# Table format
az quota list --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus --output table
```

**Key output fields**:
- `name` - Quota resource name (use in other commands)
- `properties.name.localizedValue` - Human-readable description
- `properties.limit.value` - Quota limit

---

## az quota show

Show quota limit for a specific resource.

**Syntax**:
```bash
az quota show --resource-name NAME --scope SCOPE
```

**Required**:
- `--resource-name` - Quota resource name (from `az quota list`)
- `--scope` - Azure resource URI

**Example**:
```bash
# Get DSv3 family vCPU limit
az quota show \
  --resource-name standardDSv3Family \
  --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus
```

**Key output fields**:
- `properties.limit.value` - Quota limit
- `properties.name.localizedValue` - Human-readable description
- `properties.quotaPeriod` - Reset period (e.g., P1M = 1 month)

---

## az quota update

Request quota increase for a resource.

**Syntax**:
```bash
az quota update --resource-name NAME --scope SCOPE --limit-object value=N [--resource-type TYPE] [--no-wait]
```

**Required**:
- `--resource-name` - Quota resource name
- `--scope` - Azure resource URI  
- `--limit-object` - New limit value (format: `value=N`)

**Optional**:
- `--resource-type` - Resource type (e.g., dedicated, lowPriority)
- `--no-wait` - Don't wait for completion (true/false)

**Examples**:
```bash
# Increase FSv2 family vCPUs to 100
az quota update \
  --resource-name standardFSv2Family \
  --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus \
  --limit-object value=100 \
  --resource-type dedicated

# Non-blocking request
az quota update \
  --resource-name standardFSv2Family \
  --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus \
  --limit-object value=100 \
  --no-wait true
```

---

## az quota usage list

List current usage for all resources in a scope.

**Syntax**:
```bash
az quota usage list --scope SCOPE [--max-items N] [--next-token TOKEN]
```

**Required**:
- `--scope` - Azure resource URI

**Examples**:
```bash
# List compute usage
az quota usage list --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus

# Table format
az quota usage list --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus --output table
```

**Key output**:
- `properties.usages.value` - Current usage count
- Use with `az quota show` to calculate available capacity

---

## az quota usage show

Show current usage for a specific resource.

**Syntax**:
```bash
az quota usage show --resource-name NAME --scope SCOPE
```

**Required**:
- `--resource-name` - Quota resource name
- `--scope` - Azure resource URI

**Example**:
```bash
az quota usage show \
  --resource-name standardDSv3Family \
  --scope /subscriptions/{id}/providers/Microsoft.Compute/locations/eastus
```

**Calculate available capacity**:
1. Get limit: `az quota show --resource-name {name} --scope {scope}` → limit value
2. Get usage: `az quota usage show --resource-name {name} --scope {scope}` → current usage
3. Available = Limit - Usage

**Example calculation**:
- Limit (from `az quota show`): 350 vCPUs
- Usage (from `az quota usage show`): 12 vCPUs
- **Available**: 338 vCPUs

---

## az quota create

Create quota limit for a resource. **Rarely used** - typically use `az quota update` instead.

**Syntax**:
```bash
az quota create --resource-name NAME --scope SCOPE --limit-object value=N [--resource-type TYPE]
```

**Required**:
- `--resource-name` - Quota resource name
- `--scope` - Azure resource URI
- `--limit-object` - Quota limit value

**Examples**:
```bash
# Create network quota
az quota create \
  --resource-name MinPublicIpInterNetworkPrefixLength \
  --scope /subscriptions/{id}/providers/Microsoft.Network/locations/eastus \
  --limit-object value=10 \
  --resource-type MinPublicIpInterNetworkPrefixLength

# Create ML quota
az quota create \
  --resource-name TotalLowPriorityCores \
  --scope /subscriptions/{id}/providers/Microsoft.MachineLearningServices/locations/eastus \
  --limit-object value=10 \
  --resource-type lowPriority
```

---

## Troubleshooting

### Unsupported Resource Types

Not all Azure resource providers support the quota API. If you receive a `BadRequest` error when running `az quota list`, the provider likely doesn't support quota commands.

**Example - Microsoft.DocumentDB (Cosmos DB)**:
```bash
az quota list --scope /subscriptions/{id}/providers/Microsoft.DocumentDB/locations/eastus
# Error: (BadRequest) Bad request
```

**Workarounds**:
- Check [Azure subscription limits documentation](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/azure-subscription-service-limits)
- Use Azure Portal for quota management
- Check service-specific documentation

**Testing provider support**:
```bash
# Try listing quotas
az quota list --scope /subscriptions/{id}/providers/{Provider}/locations/{region}

# BadRequest error → not supported
# List of quotas → supported
```

### REST API "No Limit" Warning

> **⚠️ CRITICAL WARNING: REST API "No Limit" is MISLEADING**
>
> If you see "No Limit", "Unlimited", or similar values in REST API or Azure Portal responses:
>
> **This DOES NOT mean unlimited capacity!**
>
> It most likely means:
> - The resource provider doesn't support the quota API
> - Quota information isn't available through this API
> - The quota is managed at a different scope
>
> **DO NOT assume unlimited capacity. Always:**
> 1. Use `az quota` CLI commands first (preferred method)
> 2. If CLI returns `BadRequest`, check [Azure service limits documentation](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/azure-subscription-service-limits)
> 3. Consult service-specific documentation for actual limits
> 4. Consider regional capacity constraints even without quota enforcement

### Common Error Codes

| Error | Cause | Solution |
|-------|-------|----------|
| `BadRequest` | Provider not supported by quota API | Use CLI (preferred) or check [Azure service limits docs](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/azure-subscription-service-limits) |
| `ExtensionNotFound` | Quota extension not installed | Run `az extension add --name quota` |
| `MissingRegistration` | Microsoft.Quota provider not registered | Run `az provider register --namespace Microsoft.Quota` |
| `InvalidScope` | Incorrect scope format | Verify: `/subscriptions/{id}/providers/{namespace}/locations/{region}` |
| `QuotaNotAvailableForResource` | Resource not available in region | Try different region |
| `RequestThrottled` | Too many API calls | Implement exponential backoff |

### Known Support Status

**Unsupported**:
- ❌ Microsoft.DocumentDB (Cosmos DB)

**Supported**:
- ✅ Microsoft.Compute (VMs, disks, cores)
- ✅ Microsoft.Network (VNets, IPs, load balancers)
- ✅ Microsoft.App (Container Apps)
- ✅ Microsoft.Storage (storage accounts)
- ✅ Microsoft.MachineLearningServices
- ✅ Microsoft.ContainerService (AKS)

<#
.SYNOPSIS
    Checks Azure quota limits and current usage for a resource provider.
.DESCRIPTION
    Installs the quota CLI extension if needed, then queries quota limits and
    current usage in a single call. Returns a table with limit, usage, and
    available capacity for every quota (or a single quota when ResourceName is provided).
.PARAMETER ResourceProvider
    Azure resource provider namespace (e.g., "Microsoft.Compute", "Microsoft.Network").
.PARAMETER Region
    Azure region to check (e.g., "eastus", "westus2").
.PARAMETER ResourceName
    Quota resource name (e.g., "standardDSv3Family"). If omitted, returns all quotas.
.PARAMETER SubscriptionId
    Azure subscription ID. Defaults to the current subscription.
.EXAMPLE
    .\check-quota.ps1 -ResourceProvider Microsoft.Compute -Region eastus
    # Shows limit, usage, and available capacity for ALL compute quotas in eastus
.EXAMPLE
    .\check-quota.ps1 -ResourceProvider Microsoft.Compute -Region eastus -ResourceName standardDSv3Family
    # Shows limit, usage, and available capacity for the DSv3 VM family only
#>
param(
    [Parameter(Mandatory)][string]$ResourceProvider,
    [Parameter(Mandatory)][string]$Region,
    [string]$ResourceName,
    [string]$SubscriptionId
)

$ErrorActionPreference = "Stop"

# Ensure the quota extension is installed
$ext = az extension list --query "[?name=='quota'].name" -o tsv 2>$null
if (-not $ext) {
    Write-Host "Installing quota extension..."
    az extension add --name quota --yes 2>$null
}

# Resolve subscription
if (-not $SubscriptionId) {
    $SubscriptionId = az account show --query id -o tsv
}

$scope = "/subscriptions/$SubscriptionId/providers/$ResourceProvider/locations/$Region"

Write-Host "Checking quotas in scope $scope"

if ($ResourceName) {
    # Single-resource mode
    Write-Host "Quota for '$ResourceName' ($ResourceProvider, $Region):"
    Write-Host ""

    $limit = az quota show --resource-name $ResourceName --scope $scope -o json 2>$null | ConvertFrom-Json
    $usage = az quota usage show --resource-name $ResourceName --scope $scope -o json 2>$null | ConvertFrom-Json

    $limitValue = $limit.properties.limit.value
    $usageValue = $usage.properties.usages.value
    $available = $limitValue - $usageValue

    [PSCustomObject]@{
        Resource  = $ResourceName
        Region    = $Region
        Limit     = $limitValue
        Usage     = $usageValue
        Available = $available
    } | Format-Table -AutoSize
} else {
    # All-quotas mode: fetch limits and usage, join by name
    Write-Host "Quotas for $ResourceProvider in ${Region}:"
    Write-Host ""

    $quotas = az quota list --scope $scope -o json 2>$null | ConvertFrom-Json
    $usages = az quota usage list --scope $scope -o json 2>$null | ConvertFrom-Json

    $usageLookup = @{}
    foreach ($u in $usages) {
        $usageLookup[$u.name] = $u.properties.usages.value
    }

    $results = foreach ($q in $quotas) {
        $name = $q.name
        $limitValue = $q.properties.limit.value
        $usageValue = if ($usageLookup.ContainsKey($name)) { $usageLookup[$name] } else { 0 }
        $available = $limitValue - $usageValue
        [PSCustomObject]@{
            Resource  = $name
            Region    = $Region
            Limit     = $limitValue
            Usage     = $usageValue
            Available = $available
        }
    }

    $results | Format-Table -AutoSize
}

#!/usr/bin/env bash
# check-quota.sh
# Checks Azure quota limits and current usage for a resource provider.
# Returns a table with limit, usage, and available capacity for every quota
# (or a single quota when resource-name is provided).
#
# Usage:
#   ./check-quota.sh <resource-provider> <region> [resource-name] [subscription-id]
#
# Examples:
#   ./check-quota.sh Microsoft.Compute eastus                          # All compute quotas with usage
#   ./check-quota.sh Microsoft.Compute eastus standardDSv3Family       # Single quota with usage

set -euo pipefail

RESOURCE_PROVIDER="${1:?Usage: $0 <resource-provider> <region> [resource-name] [subscription-id]}"
REGION="${2:?Usage: $0 <resource-provider> <region> [resource-name] [subscription-id]}"
RESOURCE_NAME="${3:-}"
SUBSCRIPTION_ID="${4:-}"

# Ensure the quota extension is installed
if ! az extension list --query "[?name=='quota'].name" -o tsv 2>/dev/null | grep -q quota; then
    echo "Installing quota extension..."
    az extension add --name quota --yes 2>/dev/null
fi

# Resolve subscription
if [ -z "$SUBSCRIPTION_ID" ]; then
    SUBSCRIPTION_ID=$(az account show --query id -o tsv)
fi

SCOPE="/subscriptions/$SUBSCRIPTION_ID/providers/$RESOURCE_PROVIDER/locations/$REGION"

echo "Checking quotas in scope $SCOPE"

if [ -n "$RESOURCE_NAME" ]; then
    # Single-resource mode
    echo "Quota for '$RESOURCE_NAME' ($RESOURCE_PROVIDER, $REGION):"
    echo ""

    LIMIT=$(az quota show \
        --resource-name "$RESOURCE_NAME" \
        --scope "$SCOPE" \
        --query "properties.limit.value" -o tsv)

    USAGE=$(az quota usage show \
        --resource-name "$RESOURCE_NAME" \
        --scope "$SCOPE" \
        --query "properties.usages.value" -o tsv)

    AVAILABLE=$((LIMIT - USAGE))

    printf "%-30s %-10s %-10s %-10s %-10s\n" "Resource" "Region" "Limit" "Usage" "Available"
    printf "%-30s %-10s %-10s %-10s %-10s\n" "--------" "------" "-----" "-----" "---------"
    printf "%-30s %-10s %-10s %-10s %-10s\n" "$RESOURCE_NAME" "$REGION" "$LIMIT" "$USAGE" "$AVAILABLE"
else
    # All-quotas mode: fetch limits and usage, join by name
    echo "Quotas for $RESOURCE_PROVIDER in $REGION:"
    echo ""

    QUOTAS_JSON=$(az quota list --scope "$SCOPE" -o json 2>/dev/null)
    USAGES_JSON=$(az quota usage list --scope "$SCOPE" -o json 2>/dev/null)

    printf "%-40s %-10s %-10s %-10s %-10s\n" "Resource" "Region" "Limit" "Usage" "Available"
    printf "%-40s %-10s %-10s %-10s %-10s\n" "--------" "------" "-----" "-----" "---------"

    echo "$QUOTAS_JSON" | python3 -c "
import json, sys

quotas = json.load(sys.stdin)
usages = json.loads('''$USAGES_JSON''')

usage_lookup = {}
for u in usages:
    usage_lookup[u['name']] = u.get('properties', {}).get('usages', {}).get('value', 0)

for q in quotas:
    name = q['name']
    limit = q.get('properties', {}).get('limit', {}).get('value', 0)
    used = usage_lookup.get(name, 0)
    avail = limit - used
    print(f'{name:<40} $REGION{\"\":<4} {limit:<10} {used:<10} {avail:<10}')
"
fi