Ship faster

As developers, we’re always looking for ways to ship faster without sacrificing quality. The constant pressure to deliver new features while maintaining clean, maintainable code can feel like an impossible balance. But what if I told you that the latest wave of AI tooling is actually living up to the hype?

Enter GitHub Copilot CLI, a game-changer that’s fundamentally changing how I approach building applications on Azure. This isn’t just autocomplete on steroids. It’s a genuine productivity multiplier that’s helping teams ship features at a pace we couldn’t have imagined just a year ago, maybe even a few months ago.

What Makes Copilot CLI Different

You’re probably familiar with GitHub Copilot in your IDE, suggesting code as you type. Copilot CLI takes a different approach. It lives in your terminal, where you spend a huge chunk of your day running commands, deploying code, and managing infrastructure.

The beauty of Copilot CLI is its understanding of context. It knows you’re working in Azure. It understands your project structure. It can suggest complete command sequences that would normally require you to dig through documentation.

Real-World Impact on Development Speed

Let me give you a concrete example. Last week, I needed to set up a new Azure Function with blob storage triggers, configure monitoring, and deploy it to a staging environment. Traditionally, this would involve:

• Looking up the Azure CLI syntax for creating function apps
• Remembering the right flags for runtime and region
• Setting up storage account connections
• Configuring Application Insights
• Writing deployment scripts
• Testing everything locally first

With Copilot CLI, I described what I needed in plain English. It generated the exact command sequence, including error handling and best practices I might have overlooked. What would have taken an hour or two took maybe 15 minutes.

Natural Language to Complex Commands

The real power comes from turning intent into action. Instead of memorizing complex Azure CLI syntax, you can ask questions like:

“Create a container app with autoscaling and connect it to my existing PostgreSQL database”

“Deploy this app to three regions with traffic manager for load balancing”

“Set up monitoring alerts for when my function execution time exceeds 5 seconds”

Copilot CLI translates these requests into proper Azure CLI commands, complete with the right parameters and flags. It’s like having a senior Azure architect sitting next to you.

Faster Iteration Cycles

Where this really shines is during rapid prototyping and feature development. When you’re exploring a new Azure service or trying to implement a feature quickly, the feedback loop is everything.

Instead of context-switching between your editor, browser, and documentation, you stay in the flow. Need to check your current resource groups? Ask. Want to deploy a quick test? Describe it. Need to roll back a change? Just say so.

This compressed feedback loop means you can iterate on features multiple times in the span it would have previously taken to do it once.

Beyond Simple Commands

Copilot CLI isn’t just about generating single commands. It helps with entire workflows. Setting up CI/CD pipelines, configuring networking rules, managing secrets and certificates – these multi-step processes become conversations rather than chores.

I’ve seen team members who were less familiar with Azure infrastructure become significantly more productive. The learning curve flattens because they’re learning by doing, with AI assistance that explains what each command does and why.

Integration with Your Development Workflow

What I appreciate most is how Copilot CLI fits into existing workflows without forcing you to change how you work. It enhances your terminal experience rather than replacing it. You can review suggested commands before running them, modify them as needed, and build up your own understanding over time.

For Azure-specific development, this means you can focus on solving business problems rather than fighting with infrastructure syntax. Your cognitive load drops dramatically when you’re not constantly switching between writing application code and remembering the exact flags for Azure CLI commands.

The Compound Effect

Here’s what I’ve noticed after a few days of using Copilot CLI daily: the time savings compound. Every command you don’t have to look up, every deployment script you don’t have to debug, every configuration you get right the first time – it all adds up.

Features that used to take a sprint now take days. Proof of concepts that took days now take hours. The velocity increase isn’t linear, it’s exponential.

Getting Started

If you’re building on Azure and haven’t tried Copilot CLI yet, I’d strongly encourage giving it a shot. The setup is straightforward, and the productivity gains start immediately. You don’t need to be an AI expert or change your entire workflow.

Start with simple commands and gradually build up to more complex operations. Let it suggest, review what it generates, and learn from the patterns. Before long, you’ll wonder how you ever managed without it.

The Future of Development

This feels like a glimpse into where software development is heading. We’re moving from memorizing syntax to expressing intent. From fighting tools to collaborating with them. From spending time on mechanical tasks to focusing on creative problem-solving.

For those of us building on Azure, Copilot CLI represents a significant step forward in how quickly we can move from idea to deployed feature. And in today’s competitive landscape, that speed matters more than ever.

The tools are here. The technology works. The only question is: how much faster could your team ship if you started using them today?

Ready to get started – https://github.com/features/copilot/cli

.

Microsoft Ignite 2025 reaffirmed that AI is now a first-class development model across the Azure platform, not just an optional add-on. Among the many announcements at Ignite, updates to Azure App Service (Web Apps) and the broader Azure AI ecosystem directly affect how developers build intelligent, cloud-native applications — including web apps augmented with AI capabilities, semantic search, and agentic workflows.

This article walks through:

• Key App Service / Web Apps announcements
• The AI platform enhancements that Web Apps can leverage
• Architectural patterns for integrating AI into web workloads
• Infrastructure automation with Terraform and secure deployment patterns

---

What’s New in Azure App Service at Ignite 2025

At Ignite 2025, the Azure App Service team announced a set of updates focused on modernization, developer productivity, and AI integration readiness:

1. Managed Instance on Azure App Service (Public Preview)

A major new capability — Managed Instance on Azure App Service — entered public preview. It is designed to simplify migration of legacy web applications (especially classic ASP.NET and .NET apps with Windows dependencies) to a managed PaaS runtime with minimal code changes.

Key benefits:

• Run legacy Windows web apps with Hyper-V nested virtualization.
• Use configuration and installation scripts for dependencies rather than rewriting code.
• Maintain automatic OS and .NET patching and updates.
• Direct RDP access to instances for troubleshooting in complex migration scenarios.

This matters for AI because modernization often precedes adding AI-driven features — a classic app first needs to run reliably on App Service before layering in services like semantic search, chat UI APIs, or automated content enrichment workflows.

---

2. Enhanced Runtime and Language Support

Alongside the Managed Instance preview, App Service continues to expand support for modern runtimes, frameworks, and developer experiences. While not AI-specific, these enhancements make it easier to host intelligent applications built with:

• .NET 8/9 and ASP.NET Core
• Node.js 20+
• Java 25 and beyond
• Containers on App Service (Linux) with improved tooling

These runtimes interoperate cleanly with Azure AI APIs and SDKs. For example, a Node.js web app can call Azure AI Search or an LLM API directly via SDK or REST.

---

Azure AI Platform Enhancements from Ignite 2025

Ignite 2025 made clear that the foundation for AI-driven web apps is not just the compute layer, but platform services that encapsulate semantic understanding, retrieval-augmented generation (RAG), and agentic workflows.

1. Microsoft Foundry — Unified AI Agent Platform

At Ignite, Azure AI Foundry was rebranded and enhanced as “Microsoft Foundry”, a unified platform for building, deploying, and governing enterprise-grade AI agents across workloads. Foundry now supports:

• Multi-agent orchestration
• Open standards for models (including Anthropic Claude and OpenAI models)
• Seamless integration with enterprise data and APIs

Foundry is not App Service, but it is the AI backbone you are likely to call from web apps for:

• Conversational AI interfaces
• Workflow automation (e.g., ticket triaging, contextual assistants)
• Long-running agentic tasks tied to user sessions or backend triggers

More on Foundry’s updates are in the Microsoft documentation. TECHCOMMUNITY.MICROSOFT.COM+1

2. Semantic Retrieval and AI Search

Azure AI Search (formerly Cognitive Search) continues to evolve with RAG-friendly patterns that integrate vector search, semantic ranking, and LLMs. This makes it much easier to add “chat with your data” experiences into web UIs.

Azure AI Search documentation is here:
🔗 https://learn.microsoft.com/azure/search/what-is-azure-ai-search

Typical patterns for Web Apps include:

• Document ingestion pipelines (Azure Blob, OneLake, Cosmos DB)
• Indexer + semantic search for natural language queries
• LLM integration to summarize and respond conversationally

---

Patterns for Integrating AI into Azure Web Apps

Below are architectural patterns you might adopt when extending web apps with AI capabilities following Ignite 2025.

Pattern 1 — RAG-Driven Conversational UI

1. Web App Frontend on App Service (e.g., React, Blazor).
2. API Layer in Azure Functions or .NET backend to handle requests.
3. Azure AI Search + vector store for semantic retrieval.
4. OpenAI or Foundry Models for response generation.

Flow:

1. User asks a question in web UI.
2. Backend calls Azure AI Search to retrieve relevant documents.
3. Retrieved context is sent to a generative model.
4. Model output is returned to the UI.

var client = new Azure.AI.OpenAI.OpenAIClient(new Uri(endpoint), new DefaultAzureCredential());
var response = await client.GetCompletionsAsync(
    deploymentOrModelName: "gpt-4.1-enterprise",
    new Azure.AI.OpenAI.CompletionsOptions
    {
        Prompts = { "Summarize these docs for a tech user: ..." }
    });

Pattern 2 — Agentic Backend Workflows

If your web app needs to trigger longer-running workflows (e.g., order fulfillment automation, customer support routing), you can:

1. Expose an HTTP trigger from your Web App or Azure Function.
2. Hand off processing to a Foundry agent (via API) that orchestrates multi-step logic.
3. Use Queues (Service Bus, Storage Queues) for reliable message passing.

This pattern decouples UI from backend processing, letting agents execute tasks with traceability and governance — critical for compliance.

---

Infrastructure as Code — Terraform & Bicep

Automation and repeatability are essential. Below is a sample Terraform snippet to provision an App Service with a Managed Identity (for secure calls to Azure AI).

Notes:

provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "rg" {
  name     = "rg-webapp-ai"
  location = "WestEurope"
}

resource "azurerm_app_service_plan" "plan" {
  name                = "asp-webai"
  resource_group_name = azurerm_resource_group.rg.name
  sku {
    tier = "PremiumV4"
    size = "P1v4"
  }
}

resource "azurerm_app_service" "webapp" {
  name                = "webapp-ai"
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location
  app_service_plan_id = azurerm_app_service_plan.plan.id

  identity {
    type = "SystemAssigned"
  }

  site_config {
    dotnet_framework_version = "v6.0"
  }

  app_settings = {
    "WEBSITE_RUN_FROM_PACKAGE" = "1"
    "AZURE_OPENAI_ENDPOINT"     = var.openai_endpoint
    "AZURE_OPENAI_MODEL"        = var.openai_model
  }
}

1. Use managed identities to authenticate to Azure AI services instead of static keys.
2. You can extend this snippet with Private Endpoints, Key Vault references, and app settings for AI service integration.

Terraform vs Bicep vs ARM:

• Terraform excels with multi-cloud teams and state management.
• Bicep/ARM provide first-class Azure tooling and tighter integration with Azure RBAC.
• Choose based on team skills and governance requirements.

---

Security, Governance, and Identity

Ignite announcements highlighted enterprise-grade security for AI agents and services, including identity integration and access policies. For Web Apps calling AI APIs:

• Use Managed Identity and Azure RBAC instead of connection strings.
• Store secrets (if needed) in Azure Key Vault with MSI access.
• Secure backend APIs with Azure AD tokens.

---

Summary

Ignite 2025 reinforced that AI is deeply woven into the future of Azure compute and application platforms:

• Azure App Service continues to modernize with managed instances, enhanced runtimes, and improved migration tooling.
• The Azure AI ecosystem — especially Microsoft Foundry and Azure AI Search — enables developers to add semantic, conversational, and agentic capabilities to web apps.
• Architectural patterns (RAG, agent workflows) and secure automation (Terraform, managed identity) help deliver production-grade intelligent applications.

As you plan your next wave of web apps, consider AI as a core design axis, not an afterthought.

---

Further Reading

• Azure App Service documentation — https://learn.microsoft.com/azure/app-service/
• Azure AI services overview — https://learn.microsoft.com/azure/ai-services/what-are-ai-services
• Azure AI Search documentation — https://learn.microsoft.com/azure/search/what-is-azure-ai-search
• Microsoft Foundry docs — https://learn.microsoft.com/azure/ai-foundry/overview

This years Microsoft Build was full of new releases, new services, new ways of doing things, and yep, lots of AI. The following are just some of the areas that grabbed my interest whilst attending the conference, due to working at it, I havent had time to try the demos, check out some of the announcements and get hands on with the tech that has newly been released, but I will in the coming weeks.

If like me you havent managed to catchup on the announcements then you can read the book of news for Build 2025.

If you are looking to upgrade your existing .net Framework application to .net Core then checkout thiese links:-

Docs: https://learn.microsoft.com/en-us/dotnet/core/porting/upgrade-assistant-overview
Upgrade Extension: https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.upgradeassistant

If you would like co-pilot to help you upgrade your version of a .net Core application then here are some very useful links.

• Upgrading a .NET 6 repo to .NET 9 with GitHub Copilot – Upgrading a .NET 6 repo to .NET 9 with GitHub Copilot
• https://devblogs.microsoft.com/dotnet/github-copilot-upgrade-dotnet/ – Accelerate Your .NET Upgrades with GitHub Copilot
• https://learn.microsoft.com/en-us/dotnet/core/porting/github-copilot-app-modernization-overview – What is GitHub Copilot app modernization – upgrade for .NET?
• http://aka.ms/ghcp-appmod/dotnet-upgrade-vsix – GitHub Copilot app modernization – upgrade for .NET
• https://learn.microsoft.com/en-us/dotnet/core/porting/github-copilot-app-modernization-faq – GitHub Copilot app modernization – upgrade for .NET FAQ
• https://dotnet.microsoft.com/en-us/platform/upgrade – Agent mode in Visual Studio makes .NET upgrades easier than ever

There is also some help available if you are just starting out and would like help deploying your application to Azure – Quickstart: Deploy your application to Azure with agent mode in GitHub Copilot for Azure

If you are interested in Hosting remote MCP Server’s in Azure App Service then this articlae has you covered – https://techcommunity.microsoft.com/blog/appsonazureblog/host-remote-mcp-servers-in-azure-app-service/4405082

Two of my favourite annoucements recently were the GitHub CoPilot Coding Agent and the new SRE Agent coming soon (you can sign up for this preview now!) and read more about the SRE agent – https://techcommunity.microsoft.com/blog/azurepaasblog/introducing-azure-sre-agent/4414569

Interested in some AI Labs then look no further than – https://ai.azure.com/labs

Maybe you like creating videos and now within Azure you can create high-quality visual content with GPT-Image-1 and Sora on Azure OpenAI—tailored for professional use cases – https://github.com/Azure-Samples/visionary-lab

Introduction

This blog post is part of this years Azure Spring Clean an event which is ran to promote well managed Azure tenants. To achieve this, they have community driven articles that highlight best-practice, lessons learned, and help with some of the more difficult topics of Azure Management.

Azure Policy is a powerful governance tool that helps organizations enforce compliance across their Azure environments. By automating the deployment of Azure Policies using Bicep and the Azure Verified Modules (AVM) GitHub repository, you can ensure consistent policy enforcement while leveraging modular, reusable infrastructure as code.

This guide assumes you already have your environment set up in VS Code, including Bicep tooling and Azure CLI authentication.

Prerequisites

Before deploying Azure Policies with Bicep, ensure you have:

• VS Code with the Bicep extension installed.
• Azure CLI installed and authenticated (az login).
• Bicep CLI installed (az bicep install if needed).
• Git installed and cloned the Azure Verified Modules (AVM) repository.
• Appropriate permissions to create and assign policies in Azure.

Deploying Policies to Management Groups and Subscriptions

Deploying policies at the management group level is a best practice for organizations that manage multiple subscriptions under a common governance framework. By applying policies at this higher level, you can ensure:

• Consistency: Enforce compliance standards across all subscriptions within the management group without the need for redundant deployments.
• Efficiency: Reduce operational overhead by managing policies centrally instead of applying them individually to each subscription.
• Scalability: As new subscriptions are added to the management group, they automatically inherit the assigned policies, ensuring continuous compliance.

To apply policies at different scopes, use the following commands:

Deploying to a Management Group

$location = ‘West Europe’
$management-group-id = ‘mg-demo’

az deployment mg create \
  --management-group-id $management-group-id \
  --location $location \
  --template-file main.bicep \
  --parameters @parameters.json \
  --name MGPolicyDeployment

Deploying to a Subscription

az deployment sub create \
  --location eastus \
  --template-file main.bicep \
  --parameters @parameters.json \
  --name SUBPolicyDeployment

You can also check in the Azure Portal under Policy -> Assignments

Lets take a look at some example Azure Policies you may want to add to your management groups. In this example I would add them to a file called deployPolicyMg.bicep

targetScope = 'managementGroup'

@description('Policy Assignment Management Group - Allowed Locations')
module assignAllowedLocationPolicy 'policyAssignmentMg.bicep' = if (deployAllowedLocations) {
  name: 'AllowedLocations'
  params: {
    name: 'Allowed Locations'
    displayName: 'Allowed Locations'
    policyDefinitionId: '/providers/Microsoft.Authorization/policyDefinitions/e56962a6-4747-49cd-b67b-bf8b01975c4c'
    location: primaryLocation
    identity: 'None'
    parameters:{
      listOfAllowedLocations: {
        value: allowedLocations
    }
  }
}
}

@description('Policy Assignment Management Group - ISO 27001-2013')
module assignIso27001Policy 'policyAssignmentMg.bicep' = if (deployIso27001Policy) {
  name: 'Iso27001'
  params: {
    name: 'ISO 27001-2013'
    displayName: 'ISO 27001-2013'
    policyDefinitionId: '/providers/Microsoft.Authorization/policySetDefinitions/89c6cddc-1c73-4ac1-b19c-54d1a15a42f2'
    location: primaryLocation
    identity: 'SystemAssigned'
    roleDefinitionIds: []
  }
}

@description('Policy Assignment Management Group - Azure Security Benchmark')
module assignAscPolicy 'policyAssignmentMg.bicep' = if (deployAzureSecurityBenchmark) {
  name: 'AzureSecurityBenchmark'
  params: {
    name: 'Azure Security Benchmark'
    displayName: 'Azure Security Benchmark'
    policyDefinitionId: '/providers/Microsoft.Authorization/policySetDefinitions/1f3afdf9-d0c9-4c3d-847f-89da613e70a8'
    location: primaryLocation
    identity: 'None'
    roleDefinitionIds: []
  }
}

The above code example makes use of some variables which I add to a .bicepparameters file which would look like this:-

using './deployPolicyMg.bicep'

param deployAllowedLocations = true
param deployIso27001Policy = true
param deployAzureSecurityBenchmark = true


Lets take a look at some example Azure Policies you may want to add to a subscription. In this example I would add them to  a file called deployPolicySub.bicep

targetScope = 'subscription'

@description('Assign Policies to Subscription - Require an Owner tag on resource groups')
module assignReguireRgOwnerTagPolicy 'policyAssignmentSub.bicep' =  if (tagAtSubscriptionLevel && ownerTagResourceGroupsPolicy) {
  name: 'reguireRgOwnerTagPolicy'
  params: {
    name: 'Require an Owner tag on resource groups'
    displayName: 'Require an Owner tag on resource groups'
    policyDefinitionId: '/providers/Microsoft.Authorization/policyDefinitions/96670d01-0a4d-4649-9c89-2d3abc0a5025'
    location: primaryLocation
    identity: 'None'
    parameters:{
      tagName: {
        value: ownerTagName
    }
  }
}
}

@description('Assign Policies to Subscription - Require a DeployedBy tag on resource groups')
module assignReguireRgDeployedByTagPolicy 'policyAssignmentSub.bicep' =  if (tagAtSubscriptionLevel && deployedByTagResourceGroupsPolicy) {
  name: 'reguireRgDeployedByTagPolicy'
  params: {
    name: 'Require a DeployedBy tag on resource groups'
    displayName: 'Require a DeployedBy tag on resource groups'
    policyDefinitionId: '/providers/Microsoft.Authorization/policyDefinitions/96670d01-0a4d-4649-9c89-2d3abc0a5025'
    location: primaryLocation
    identity: 'None'
    parameters:{
      tagName: {
        value: deployByTagName
    }
  }
}
}

The code above is an example of how you could add Azure Policies into a subscription.

The above code example makes use of some variables which I add to a .bicepparameters file which would look like this:-

using './deployPolicySub.bicep'

param tagAtSubscriptionLevel = true
param ownerTagResourceGroupsPolicy = true
param deployedByTagResourceGroupsPolicy = true

Conclusion

By leveraging Azure Bicep and Azure Verified Modules, you can automate and standardize Azure Policy deployment efficiently. Start using AVM today to maintain governance and compliance effortlessly!

This year’s Festive Tech Calendar videos are available on YouTube with the link to the playlist.

A huge THANK YOU to everyone who took part, has watched the videos and learned and especially those who also donated to this years charity – thanks from all of us at the Festive Tech Calendar team!

Day 1

• Day 1 – Yippee-ki-yay! Let’s Build a Die Hard Quiz Power App using Copilot – YouTube
• Day 1 – Keynote☃️ Whispers of Winter: A Festive Poem ✨ – YouTube
• Day 1 – Christmas planning in Loop: A festive collaboration adventure! 🎅 – YouTube

Day 2

• Day 2 – Merry Scripting: Automate Festive Windows Wallpapers with PowerShell – YouTube

Day 3

• Day 3 – Deploying AVD base infrastructure using DevOps pipelines – YouTube
• Day 3 – Immersive Tour of Christmas Traditions Around the World – YouTube

Day 4

• Day 4 – Building Personalised Cloud Year in Review Videos – YouTube
• Day 4 – AKS cluster mesh in VWAN environment – YouTube
• Day 4 – No IDE Required: How CLI Tools Unleashed .NET’s Flexibility – YouTube

Day 5

• Day 5 – Magic or Ai – YouTube

Day 6

• Day 6 – Festive fun with Microsoft Designer – YouTube

Day 7

• Day 7 – How to Ace those Azure Exams! – YouTube
• Day 7 – How to Improve Your Azure Kubernetes Security Posture with Threat Model – YouTube

Day 8

• Day 8 – Jingle Bells and AI Spells: Exploring Semantic Kernel with Azure OpenAI – YouTube

Day 9

• Day 9 – Let’s create a festive greeting card together – YouTube
• Day 9 – Microsoft Defender Vulnerability Management – YouTube

Day 10

• Day 10 – Microsoft 365 Copilot: 8 Ways to Simplify Your Tasks – YouTube
• Day 10 – Building a Reliable Deployment Pipeline: Don’t Let Tests Break Your Pipeline – YouTube

Day 11

• Day 11 – Optimising Customer Experience with Dynamics 365 Contact Center: A Festive Approach – YouTube

Day 13

• Day 13 – Securing MS Fabric in the traditional way – YouTube

Day 14

• Day 14 – Personalized Event Discovery – YouTube

Day 15

• Day 15 – So, you think you can agent? – YouTube

Day 16

• Day 16 – Ho-Ho-Hold onto Your Hats! Real-Time Data Magic from Santa’s Sleigh – YouTube
• Day 16 – Transforming Non-Profit with Power Platform – YouTube

Day 17

• Day 17 – How to Make My Christmas Snowier with GitHub Copilot Workspaces – YouTube
• Day 17 – Ho Ho Whoa! 10 Tips for Data Warehousing in the Cloud – YouTube

Day 18

• Day 18 – Agentic Azure AI: Dungeons and Dragons at Christmas – YouTube
• Day 18 – Securing Tomorrow: Cybersecurity Visions for 2025 and Beyond – YouTube

Day 19

• Day 19 – Yule Log-in Safely: Entra ID Security overview – YouTube

Day 20

• Day 20 – Copilot Studio: Create a Hotel Reservation Assistant – YouTube
• Day 20 – The power of multimodal models – YouTube

Day 21

• Day 21 – AI-POWERED QUANTUM COMPUTING: THE NEW FRONTIER IN PROBLEM-SOLVING – YouTube
• Day 21 – Santa’s Workshop: Magic with AKS and Bicep! – YouTube
• Day 21 – How to create an AI Web App with Azure AI Search Vector Embeddings and Fabric Pipelines – YouTube

Day 22

• Day 22 – AI Santa’s Workshop: Custom Rhymes and Cards – YouTube
• Day 22 – The Influence of Generative AI in Festival Season Predictions for the Retail Industry – YouTube
• Day 22 – Improve Kubernetes with k8sGPT – YouTube
• Day 22 – Harnessing Simulation and Evaluation in Azure AI Studio – YouTube

Day 23

• Day 23 – Santa’s Festive Guide to Entra ID Security Defaults! – YouTube
• Day 23 – GitHub Copilot Tutorial Automate Coding, Azure, & Infrastructure in Minutes! – YouTube
• Day 23 – Building a Cyber Risk Management Action Plan to protect Santa Claus vulnerabilities – YouTube

Day 25

• Day 25 – 2024 in Cloud Native – A Festive Retrospective – YouTube
• Day 25 – The Essentials of Azure Storage: Key Concepts and Best Practices – YouTube
• Day 25 – Getting your hands dirty with SharePoint’s Brand new Centre – YouTube

Day 26

• Day 26 – #MVPWrapped, #CommunityWrapped and/or #MCTWrapped – YouTube
• Day 26 – Developing Custom Copilots with Azure AI Studio, PromptFlow and .NET – YouTube
• Day 26 – Using Purview eDiscovery to retrieve Teams chats for Incident Response! – YouTube
• Day 26 – Language Detection in Modern Applications with Azure AI – YouTube

Day 27

• Day 27 – The ABC’s of Christmas Continuity – YouTube
• Day 27 – Top 10 Ways to Save Money and Manage Cloud Costs on Microsoft Azure – YouTube
• Day 27 – Extending the PAW mentality to the cloud – YouTube

Day 28

• Day 28 – New Year, New Savings: Mastering Azure NetApp Files Cost Optimisation – YouTube

Day 29

• Day 29 – Diagram As Code – YouTube
• Day 29 – Microsoft Copilot Studio and Power platform – YouTube
• Day 29 – Want to set up your own tech meetup? Start here! – YouTube

Day 30

• Day 30 – Cowrie Honeypot Integration with Microsoft Sentinel – YouTube
• Day 30 – Aspiring .NET with Azure Open AI – YouTube

Day 31

• Day 31 – AI in Every City: embrace the magic of the holidays with Copilot!
• Day 31 – Securing Cloud Applications: Best Practices for Azure Developers and Architects
• Day 31 – Build a warp speed time-to-market API with DAB and Azure Container Apps.
• Day 31 – Query Store Advancements Recording

This year’s Festive Tech Calendar videos are available on YouTube with the link to the playlist.

This blog is about listing the posts I have that demo using Bicep with code snippets for various different scenarios.

The list of snippets below makes use of the Azure Verified Modules GitHub repo from Microsoft.

• Deploy Azure SQL Server, Database and Elastic pool in one go using Bicep!
• Azure Application Gateway using Azure Verified Modules
• Understanding and Implementing Privileged Identity Management (PIM) Using BICEP
• Implementing TDE in Azure SQL with Custom Managed Keys from Azure Key Vault
• Deploy Azure Azure Web Apps Windows and Linux using Bicep!
• Azure Firewall Rule Collection Groups: Managing Windows Updates and Time Server Sync with Microsoft’s Verified Modules
• Implementing Azure SQL Server Firewall Rules with Bicep and Azure Verified Modules
• Deploying a Log Analytics Workspace Using Azure Verified Modules

The call for speakers is open for this years Festive Tech Calendar, we are off to a slow start and we need your help with submitting session(s). Please also spread the word as the call for speakers closes at the end of the month.

The main reason for this post is to inform you about our chosen charity this year which is the Beatson Cancer Charity – we are trying to earn £2500 for this amazing charity which is based in Glasgow, Scotland near where I live.

---

Their Mission

Beatson Cancer Charity supports people affected by cancer, every step of the way. We make the journey easier by transforming the way cancer care is funded and delivered. We provide services, as well as funding specialists, research and education to invest in a better future for cancer patients and their families.

From the hospital wards, right to the heart of the communities that The Beatson West of Scotland Cancer Centre serves, we believe everyone should experience cancer with care, with love and with hope. We are with our patients and their families for every step of the journey.

By working within NHS environments, Beatson Cancer Charity is ideally placed to understand the needs of patients and staff. We respond by providing services and funding that enhance and strengthen NHS care and enable patients and their families to be helped swiftly and compassionately. At the same time our independence as a charity allows us to develop and extend our services further into the heart of Scottish communities to support more people with cancer before, during and after treatment.

Amongst patients and the wider community, we are best known for our award-winning Wellbeing Centre and specialist support at The Beatson West of Scotland Cancer Centre and across hospitals in five health boards. While clinical and research professionals recognise us for our ongoing commitment to more effective cancer services, funding additional specialist staff and supporting cutting-edge cancer research and education.

All our work is made possible by our supporters. It is their generosity which allows Beatson Cancer Charity to deliver an innovative and patient-focused approach to cancer care and change the lives of those affected by the disease every day.

If you have any spare cash, even a very little goes a long way then please donate to our just giving page at the link below.

https://www.justgiving.com/page/festive-tech-calendar-2024

Thank you for taking the time to read this and I will update this blog post as we get more donations.

This blog post is my entry into this years AzureBackToSchool community event organized and ran by Dwayne Natwick https://x.com/DwayneNcloud

In this blog post I wanted to cover what I consider to be some hiden gem Azure WorkBooks within Azure Advisor.

The 3 main workbooks I wanted to bring to your attention are as follows:-

• Reliability
• Service Retirement
• Cost Optimization

The 3 Workbooks I will refer to can be found within the Azure Portal, search for Advisor and then click on Workbooks on the left hand menu and you can see them as below:-

Lets take them in turn

Reliability Workbook

---

Service Retirement Workbook

This workbook is awesome for finding any resources with your Azure Environment that are due to retire or have alredy retired.

Now not all services are listed here but the teams at Microsoft are working on adding more all of the time.

The workbooks like the following: –

In the screenshot above we can see that the list of services and their due retirement date, luckily I have zero resources within my subscription(s) which had anyting due to retire, you can see this where it says None with a green tick, but if I did then I would be able to see how many resources are due to expire or that have already expired.

I get lots of emails at work telling me that service X is about to retire and I always wondered how do we manage this and the answer is to use this workbook to locate the resources which are due for retiring.

If the service in question doesnt exist within this workbook then you have a couple of options, you can either write a KQL query with Azure Resource Graph or figure out how to do similar using PowerShell. A simple ChatGPT prompt can help with this if required.

Summary

If you want to find resources that have or are about to expire then start with this workbook and then go from there.

---

Cost Optimization WorkBook

If you would like recommendations and detailed information regarding how to save money and not sure how to do this using Cost Analysis then this workbook is a gem.

The workbook itself looks like this:-

In the screenshot abve I have selected the Usage Optimization tab (highlighted in red) and here I can check lots of things including:-

Compute

• Virtual Machines in a stopped state
• Advisor Recommendations

Storage

• Am I using any v1 Storage accounts
• Are there any unattached Managed Disks
• Are there any Premium disks attached to powered off virtual machines
• Are there any Old Managed Disks snapshots
• Are there any Orphaned Managed Disks snapshots
• Are there any idle backups
• Advisor Recommendations

Networking

• Avoid multiple Firewall instances in the same region
• Recommendations for Application Gateways
• Recommendations for Load Balancers
• Unattached Public IPs
• Recommendations for Virtual Network Gateways
• Recommendations for NAT Gateways
• Recommendations for Express Route
• Recommendations for Private DNS
• Advisor Recommendations

Databases

• Recommendations for CosmosDB, SQL DB and SQL Elastic Pool

Sustainability

• Carbon Optimization recommendations

Summary

I think you might find the Cost Optimization WorkBook awesome and it more than likely will save you money in some way(s).