Azure SDK for Python - How to check for Available Resource Names

If we wanted to check in Azure whether or not a given resource name is still available, we can do so relatively easily within the Azure Portal by navigating to the All resources blade, making sure the subscription filter has all relevant subscriptions in scope and typing in the name that we want to check.

This is fine for a manual approach - but how could we do this programmatically?

Azure REST API

One option would be to use the Azure REST API [1]. Most Azure services include a REST API capability for checking for available resource names - let's take Storage Accounts as an example [2].

We could create a POST request against https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.Storage/checkNameAvailability?api-version=2022-09-01 in order to verify the availability:

from azure.identity import AzureCliCredential
import requests

credential = AzureCliCredential()
access_token = credential.get_token("https://management.core.windows.net/")
bearer_token = f"Bearer {access_token.token}"

r_url = 'https://management.azure.com/subscriptions/{subscription_id}/providers/Microsoft.Storage/checkNameAvailability?api-version=2022-09-01'
r_header = {'Content-Type': 'application/json', 'Authorization' : bearer_token}
r_body = {'name': '{storage_account_name}','type': 'Microsoft.Storage/storageAccounts'}

result = requests.post(headers=r_header,url=r_url,json=r_body)

print(result.json())

If the storage account name was already used, the response should be:

{'nameAvailable': False, 'reason': 'AlreadyExists', 'message': 'The storage account named storage_account_name is already taken.'}

Otherwise, the response would simply be:

{'nameAvailable': True}

As you can see, this works well, however, there are drawbacks:

• Not all Azure services offer the capability for checking the available name through the Azure REST API.
• If they do, we need to know the REST API URL.
• We can only run the query against a single subscription.

To resolve the third point, we could first receive a list of available subscriptions and then iterate through each subscription and query the REST API on a per-subscription basis. This would work as well, however the other two drawbacks would still apply.

Azure SDK for Python

A simpler approach - since we are using Python anyways in this example - would be to use the Azure SDK for Python [6].

from azure.identity import AzureCliCredential
from azure.mgmt.storage import StorageManagementClient
credential = AzureCliCredential()

subscription_id = '{subscription_id}'
storage_account_name = '{storage_account_name}'

storage_client = StorageManagementClient(credential, subscription_id)



availability_result = storage_client.storage_accounts.check_name_availability(
    { 
        "name": storage_account_name
    }
)

print(availability_result)

Similar to what we saw when querying the Azure REST API, the result indicating that the name was already used would look like this:

{'additional_properties': {}, 'name_available': False, 'reason': 'AlreadyExists', 'message': 'The storage account named storage_account_name is already taken.'}

If the name was still available, the response would be:

{'additional_properties': {}, 'name_available': True, 'reason': None, 'message': None}

This approach includes similar drawbacks as using the REST API directly.

• Not all Azure services offer the capability for checking the available name.
• If they, do we need to import the corresponding Python library.
• We can only run the query against a single subscription.

Again, the last point can be remediated by using the SubscriptionClient Class [4], generating a list of subscription id's and iterating through it - however, the approach might not be very flexible.

Azure Resource Graph

Fortunately, Azure offers a great capability called Azure Resource Graph [3], which we can also use through the Azure SDK for Python.

Below, we see two functions created. resource_graph_query is used to run a query against Azure Resource Graph [5]. check_name_availability is then used to create and execute the query against a specific name - and optionally, resource type.

from azure.identity import AzureCliCredential
from azure.mgmt.resource import SubscriptionClient
import azure.mgmt.resourcegraph as arg

credential = AzureCliCredential()

def resource_graph_query( query ):
    # Get your credentials from Azure CLI (development only!) and get your subscription list
    subs_client = SubscriptionClient(credential)
    subscriptions_dict = []

    for subscription in subs_client.subscriptions.list():
        subscriptions_dict.append(subscription.as_dict())

    subscription_ids_dict = []

    for subscription in subscriptions_dict:
        subscription_ids_dict.append(subscription.get('subscription_id'))

    # Create Azure Resource Graph client and set options
    resource_graph_client = arg.ResourceGraphClient(credential)
    resource_graph_query_options = arg.models.QueryRequestOptions(result_format="objectArray")

    # Create query
    resource_graph_query = arg.models.QueryRequest(subscriptions=subscription_ids_dict, query=query, options=resource_graph_query_options)

    # Run query
    resource_graph_query_results = resource_graph_client.resources(resource_graph_query)

    # Show Python object
    return resource_graph_query_results

def check_name_availability(resource_name, resource_type=None):

    if(resource_type):
        rg_query = f"Resources | where name =~ '{resource_name}' | where type =~ '{resource_type}'"
    else:
        rg_query = f"Resources | where name =~ '{resource_name}'"


    rg_results = resource_graph_query(rg_query)

    results_dict = []

    if(rg_results.data):
        availability = False
    else:
        availability = True

    results_dict = dict({
        'resource_name': resource_name,
        'available': availability
    })

    return results_dict

r_name = '{storage_account_name}'
r_type = 'Microsoft.Storage/storageAccounts'

result = check_name_availability(resource_name=r_name, resource_type=r_type)

print(result)

Thanks to Azure Resource Graph, we can just pass a list of subscription id's and query them all at once with a single call. Particularly when checking hundreds or thousands of subscriptions at once, Resource Graph improves performance significantly.

Furthermore, this approach prevents us from having to pass in exact REST API URLs or import Python libraries for the individual Azure resources that we are querying.

The results of above code would be like this (but could obviously be improved or extended) if the resource existed already:

{'resource_name': 'storage_account_name', 'available': False}

Contrarily, if the resource did not exist yet, the response would be True:

{'resource_name': 'storage_account_name', 'available': True}

References

#	Title	URL
1	Azure REST API reference	https://learn.microsoft.com/en-us/rest/api/azure/
2	Storage Accounts - Check Name Availability	https://learn.microsoft.com/en-us/rest/api/storagerp/storage-accounts/check-name-availability?tabs=HTTP
3	What is Azure Resource Graph?	https://learn.microsoft.com/en-us/azure/governance/resource-graph/overview
4	SubscriptionClient Class	https://learn.microsoft.com/en-us/python/api/azure-mgmt-subscription/azure.mgmt.subscription.subscriptionclient?view=azure-python
5	Quickstart: Run your first Resource Graph query using Python	https://learn.microsoft.com/en-us/azure/governance/resource-graph/first-query-python
6	Use the Azure libraries (SDK) for Python	https://learn.microsoft.com/en-us/azure/developer/python/sdk/azure-sdk-overview