# 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)

#!/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