DEV Community: Saurabh Shivgunde

How to stay up-to-date with Microsoft Azure

Saurabh Shivgunde — Fri, 26 Feb 2021 11:05:10 +0000

Microsoft Azure is huge and is constantly changing! It has a plethora of services under it which is currently greater than any other cloud service provider. It's hybrid connectivity and the cost factor has made it an enterprise favorite.

The rate at which Azure keeps evolving is amazing. There are new services coming out and the existing services are constantly being enhanced with new features. This change of pace also means that individuals and organizations have to adapt themselves with the new processes. If you are someone who is responsible for helping your organization keep up with the change or you are someone who is interested in learning Azure then you need to stay up-to-date.

Here's how you can do it.

Subscribe to Azure Updates RSS feeds

Subscribing to RSS feeds is THE quickest way to stay current with anything. It allows you to get the updates regarding your favorite content in one centralized location.

You can install a browser extension like RSS Feed Reader which will allow you to see the updates to your subscriptions instantaneously in your browser. If you prefer to not get distracted by the frequent updates in your browser, you can install an app like Aggregator to read the updates whenever you want on your mobiles.

I have been following the updates from below sources:

Azure updates: You can review the Azure updates for updates about different products in Azure. It gives a brief summary of the updates with links to additional resources. Subscribe to these updates via Azure updates RSS feed.
Azure blog: The Azure blog covers the important announcements for the Azure platform. Subscribe to the blog via Azure blog RSS feed.
Service blogs: If you are interested in specific Azure services then you can follow service-specific blogs. Individual services publish their blogs. For example, here is the blog for Azure App Service. Similarly, you can find other service blogs as well.

Azure Charts

If you don't like going through feeds and updates from various sources and prefer visualizing the data instead, you can refer the Azure Charts website.

The Azure Charts website is developed by Alexey Polkovnikov. The website pulls together all the stats from different updates, RSS channels and webpages. It has a lot of amazing features one of which is Azure Heat Map.

It lists all the Azure services and then highlights the ones which have recent updates. You can also click on the product tile which will take you to official website to see the updates for the specific service.

Azure This Week - A Cloud Guru

A fun way to stay up-to-date. Azure This Week is a weekly video series from A Cloud Guru where ACG instructors recap the past week's developments in the world of Azure.

If you're not a big fan of reading and scrolling through different feeds, then this a great way to catch up with the latest updates by watching a 3-5 minute video every week. It also contains some important links and resources on each episode page making the updates easy to follow.

And that's it! Sometimes keeping track of all the changes can be hard. I try to keep pace as much as I can. Hope that this article helps you do the same.

Deliver ARM templates at speed using Template Specs in Azure

Saurabh Shivgunde — Wed, 17 Feb 2021 06:27:36 +0000

A template spec is used to store your Azure Resource Manager (ARM) templates securely in Azure environment. Microsoft.Resources/templateSpecs is the resource type for template specs.

Using template specs you can share ARM templates with users in your organization. They also support versioning which we will see later in this post.

Why to use template specs?

Suppose you are working on Infrastructure development using ARM templates in your organization. There are several issues when trying to share these templates with other teams. If the templates are stored in a repository or storage account, users won't be able to access it unless they have required permissions. Even if permission is granted users will deploy using their own local version of templates which can eventually become outdated as you keep on updating the template.

Template Specs in Azure are protected by Azure Role-Based Access Control (RBAC). So you can securely store the templates in a resource group and control access using RBAC in Azure itself. When the reference architectures in your organization change over time, you can update the template specs with newer versions.

Create a new template spec with linked template

When you create a template spec, you just pass the main template file to the CLI commands. If there are linked templates referenced inside the main template file, those will be packaged together with the main template in a single template spec resource.

Create a main template named azuredeploy.json with the following JSON in your working directory:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "appServicePlanName": {
            "type": "string",
            "metadata": {
                "description": "Enter a name for app service plan"
            }
        },
        "appServiceName": {
            "type": "string",
            "metadata": {
                "description": "Enter a name for app service"
            }
        }
    },
    "functions": [],
    "variables": {},
    "resources": [
    {
        "name": "webappDeployment",
        "type": "Microsoft.Resources/deployments",
        "apiVersion": "2020-06-01",
        "properties": {
            "mode": "Incremental",
            "templateLink": {
                "relativePath": "artifacts/webapp.json"
            },
            "parameters": {
                "appServicePlanName": {
                    "value": "[parameters('appServicePlanName')]"
                },
                "appServiceName": {
                    "value": "[parameters('appServiceName')]"
                }
            }
        }
    }
    ],
    "outputs": {}
}

Note the deployment resource in above template references a linked template webapp.json. We will create this linked template next.

In your working directory create a new directory named artifacts and create a template named webapp.json inside the directory with the following JSON:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "appServicePlanName": {
            "type": "string",
            "metadata": {
                "description": "Name of app service plan"
            }
        },
        "appServiceName": {
            "type": "string",
            "metadata": {
                "description": "Name of app service"
            }
        }
    },
    "functions": [],
    "variables": {},
    "resources": [
        {
            "name": "[parameters('appServicePlanName')]",
            "type": "Microsoft.Web/serverfarms",
            "apiVersion": "2019-08-01",
            "kind": "app",
            "location": "[resourceGroup().location]",
            "sku": {
                "name": "S1"
            }
        },
        {
            "name": "[parameters('appServiceName')]",
            "type": "Microsoft.Web/sites",
            "apiVersion": "2019-08-01",
            "kind": "app",
            "location": "[resourceGroup().location]",
            "dependsOn": [
                "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]"
            ],
            "properties": {
                "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', 'appServicePlan1')]"
            }
        }
    ],
    "outputs": {}
}

Deploy the template spec

To deploy the template spec, you can use various Azure tools like PowerShell, Azure CLI, Azure portal, REST, and other supported SDKs and clients. We will use Powershell to deploy our template spec.

Open a Powershell terminal in your working directory and run the following Powershell cmdlets to create a new resource group:

$rg = "TemplateSpecsRG"

New-AzResourceGroup `
  -Name $rg `
  -Location eastus

Then run the New-AzTemplateSpec cmdlet to create a new template spec based on the above templates:

New-AzTemplateSpec `
  -Name webappSpec `
  -Version "1.0" `
  -ResourceGroupName $rg `
  -Location eastus `
  -TemplateFile "azuredeploy.json"

When the cmdlet executes successfully, you can view the deployed spec using Get-AzTemplateSpec cmdlet:

> Get-AzTemplateSpec -ResourceGroupName $rg -Name webappSpec


Id                    : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/TemplateSpecsRG/providers/Microsoft.Resou
                        rces/templateSpecs/webappSpec
Name                  : webappSpec
ResourceGroupName     : TemplateSpecsRG
SubscriptionId        : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Location              : eastus
Versions              : 1.0
CreationTime(UTC)     : 2/17/2021 5:42:57 AM
LastModifiedTime(UTC) : 2/17/2021 5:43:02 AM

In the portal too, you can navigate to the resource group and view the template spec resource:

When you go to the template spec resource screen, you can find that it contains a main template and the linked template that we deployed. Note that the version you entered is also displayed as Latest Version.

You can also drill down on the templates and see the content in the portal itself.

Modify the template spec

Now suppose the architecture gets updated and a new storage account needs to be added along with the web app. We will modify the existing template spec to add a new storage account as a linked template.

Modify the azuredeploy.json file and add a new deployment resource. The modified template should like as below:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "appServicePlanName": {
            "type": "string",
            "metadata": {
                "description": "Enter a name for app service plan"
            }
        },
        "appServiceName": {
            "type": "string",
            "metadata": {
                "description": "Enter a name for app service"
            }
        },
        "storageAccountName": {
            "type": "string",
            "metadata": {
                "description": "Enter a name for storage account"
            }
        },
        "storageAccountType": {
            "type": "string",
            "defaultValue": "Standard_LRS",
            "metadata": {
                "description": "Specify the storage account type"
            }
        }
    },
    "functions": [],
    "variables": {},
    "resources": [
        {
            "name": "webappDeployment",
            "type": "Microsoft.Resources/deployments",
            "apiVersion": "2020-06-01",
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                    "relativePath": "artifacts/webapp.json"
                },
                "parameters": {
                    "appServicePlanName": {
                        "value": "[parameters('appServicePlanName')]"
                    },
                    "appServiceName": {
                        "value": "[parameters('appServiceName')]"
                    }
                }
            }
        },
        {
            "name": "storageAccountDeployment",
            "type": "Microsoft.Resources/deployments",
            "apiVersion": "2020-06-01",
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                    "relativePath": "artifacts/storageAccount.json"
                },
                "parameters": {
                    "storageAccountName": {
                        "value": "[parameters('storageAccountName')]"
                    },
                    "storageAccountType": {
                        "value": "[parameters('storageAccountType')]"
                    }
                }
            }
        }
    ],
    "outputs": {}
}

Create a new template storageAccount.json in the artifacts directory with the following JSON:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "storageAccountName": {
            "type": "string",
            "metadata": {
            "description": "Storage Account Name"
            }
        },
        "storageAccountType": {
            "type": "string",
            "defaultValue": "Standard_LRS",
            "allowedValues": [
            "Standard_LRS",
            "Standard_GRS",
            "Standard_ZRS",
            "Premium_LRS"
            ],
            "metadata": {
            "description": "Storage Account type"
            }
        },
        "location": {
            "type": "string",
            "defaultValue": "[resourceGroup().location]",
            "metadata": {
            "description": "Location for all resources."
            }
        }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Storage/storageAccounts",
            "apiVersion": "2019-04-01",
            "name": "[parameters('storageAccountName')]",
            "location": "[parameters('location')]",
            "sku": {
            "name": "[parameters('storageAccountType')]"
            },
            "kind": "StorageV2",
            "properties": {}
        }
    ],
    "outputs": {}
}

Now re-deploy the template spec with a newer Version:

New-AzTemplateSpec `
  -Name webappSpec `
  -Version "1.1" `
  -ResourceGroupName $rg `
  -Location eastus `
  -TemplateFile "azuredeploy.json"

If you enter the same version as the previous one, it will overwrite the template spec. You can either update the existing version or publish a new version as needed.

Now when you run the Get-AzTemplateSpec cmdlet, you can see two versions for your template spec in the output:

> Get-AzTemplateSpec -ResourceGroupName $rg -Name webappSpec


Id                    : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/TemplateSpecsRG/providers/Microsoft.Resou
                        rces/templateSpecs/webappSpec
Name                  : webappSpec
ResourceGroupName     : TemplateSpecsRG
SubscriptionId        : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Location              : eastus
Versions              : {1.0, 1.1}
CreationTime(UTC)     : 2/17/2021 5:42:57 AM
LastModifiedTime(UTC) : 2/17/2021 6:00:07 AM

After the cmdlet executes, verify that the Latest Version is updated in the portal and a new artifact storageAccount.json is added to the template spec

This way you can develop and share ARM templates quickly with the users in your organization.

You can also refer to the below Youtube video on Microsoft Azure channel.

Start leveraging template specs right away!

Remove empty Azure resource groups using Powershell

Saurabh Shivgunde — Thu, 07 Jan 2021 14:01:11 +0000

Each time you create a new resource in Azure, you have to place it in a logical container called as "Resource Group". When the resources are deleted it leaves behind an empty resource group.

As your subscription grows in size, empty resource groups can also increase in number. To keep things easy to manage, it is a good practice to delete these empty groups. We will see how to create a custom Powershell script to find and delete the empty resource groups.

Prerequisites:

Azure Powershell (For managing Azure resources from Powershell)
Service Principal (To authenticate with Azure)

Authenticating with Azure

The $ErrorActionPreference = "Stop" below tells the script to stop execution if it encounters an error while executing. You can change this behavior to suit your needs. Check the about_Preference_Variables link to learn more on this.

$ErrorActionPreference = "Stop"
$tenantId = "<YOUR_TENANT_ID>"

# Enter your service principal client ID & secret here.
# You will get the client ID and client secret after creating the service principal.
$clientId = "<YOUR_CLIENT_ID>"
$clientSecret = "<YOUR_CLIENT_SECRET>"
$secClientSecret = ConvertTo-SecureString $clientSecret -AsPlainText -Force
$credentials = New-Object System.Management.Automation.PSCredential ($clientId, $secClientSecret)

# Authenticate using the service principal
Connect-AzAccount -ServicePrincipal -Credential $credentials -Tenant $tenantId -WarningAction SilentlyContinue | Out-Null

Once authentication is successful, we will fetch the list of subscriptions

# Get the list of subscriptions
$subscriptionIds = (Get-AzSubscription).Id

Loop through the subscriptions and perform the cleanup

The below code snippet loops through the subscription and finds the empty resource groups. Then it asks for confirmation before performing the delete operation.

# Loop through the list of subscriptions and find empty resource groups
foreach ($subscription in $subscriptionIds) {
    Set-AzContext -SubscriptionId $subscription | Out-Null

    Write-Host "`n--------- Working on subscription $subscription ----------`n"

    $emptyRgs = New-Object System.Collections.ArrayList

    $rgs = Get-AzResourceGroup

    Write-Host "Empty resource groups:- "

    foreach ($rg in $rgs) {
        $resourceCount = (Get-AzResource -ResourceGroupName $rg.ResourceGroupName).Count

        if ($resourceCount -eq 0) {            
            Write-Host $rg.ResourceGroupName
            $emptyRgs.Add($rg) | Out-Null
        }
    }

    if ($emptyRgs.Count -eq 0) {
        Write-Host "No empty resource groups found in this subscription" -ForegroundColor Red
    }
    else {
        # Ask permission to delete the empty resource groups
        $msg = "`nDo you want to delete the above resource groups? [y/n]"

        $choice = [string]::empty

        while ($choice -notmatch "[y|Y|n|N]") {
            $choice = Read-Host -Prompt $msg
        }

        if ($choice -match "[y|Y]") {
            $emptyRgs | Remove-AzResourceGroup -Force -AsJob | Out-Null
            Write-Host "`n", $emptyRgs.Count, "resource groups will be deleted" -ForegroundColor Green
        }
        else {
            Write-Host "`nNo resource groups were deleted" -ForegroundColor Red
        }
    }
    Write-Host "`n---- Finished working on subscription $subscription -----`n"
}

Notice that we have used -AsJob attribute for Remove-AzResourceGroup cmdlet here which performs the delete operation in the background. This is particularly useful when there are a lot of empty resource groups and we don't want to wait for each delete operation to complete.

Out-Null is used for various Powershell cmdlets. It suppresses the cmdlet output and helps keep the script output clean and just present the relevant information to the user executing the script.

Below is a sample output for the above script:

You can find the full Powershell script on Github link below:

srs2210 / azure-cleanup-empty-rg

Find and delete empty resource groups in Azure using Powershell

Hope you find this post useful 😄