Awilsons on Black Marble

MSTest | Controlling Parallelism of Test Runs

Andrew Wilson — Mon, 09 Feb 2026 00:00:00 +0000

Introduction

I have been writing integration tests using MSTest recently and have encountered the need to control the level of parallelism required. MSTest, by default, runs your tests in parallel to maximise performance and reduce overall test execution time. This is great for independent unit tests, but it can quickly become a problem when you’re writing integration tests that access shared resources like databases, APIs, or cloud services. I recently encountered this issue when my integration test suite started failing randomly due to parallel tests competing for the same data or creating conflicting test data. The solution? Learning to control MSTest’s parallelism settings.

Azure Logic Apps Standard | Send Custom Events to Application Insights

Andrew Wilson — Tue, 03 Feb 2026 00:00:00 +0000

Introduction

When building integration workflows with Azure Logic Apps Standard, there’s often a need to track custom business events that sit between pure technical telemetry and business process monitoring. Recently, while authoring a Logic App Standard workflow, I needed to track the total number of items processed along with a breakdown of successful versus failed processing attempts.

While Logic Apps provides excellent run history and built-in diagnostics, custom events allow you to capture specific business actions and metrics that align with your reporting requirements. In this post, I’ll show you how to send custom events directly to Azure Application Insights using the ingestion endpoint from the Application Insights connection string.

Azure Function Apps | OkObjectResult Returns Empty JSON After Moving to .NET 9 Isolated Worker Runtime

Andrew Wilson — Wed, 03 Dec 2025 00:00:00 +0000

The Problem

I recently upgraded an Azure Function from .NET 8 to .NET 9, and at the same time migrated from the in-process worker to the isolated worker model. After the upgrade, my function that returned OkObjectResult started returning an empty JSON object {} instead of the expected data.

[Function("MyFunction")]
public IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
{
 var data = new MyResponse { Name = "Test", Value = 123 };
 return new OkObjectResult(data); // Returns {} instead of expected JSON
}

Why This Happens

There are two key changes that caused this issue:

Bicep Tips and Tricks | #9 | Prevent a Nasty Refactor with Function Namespaces

Andrew Wilson — Wed, 17 Sep 2025 00:00:00 +0000

Problem Space

There have been few times where I have landed into this particular predicament whereby either by my own doing or through the use of another’s code base, a deep nested or thoroughly utilised (parameter/variable/or other defined item) has been created with the same name as a Bicep function. As by Murphy’s law, its only once you have reached this point of no return that you realise that your items name conflicts.

Bicep Tips and Tricks | #8 | Agnostic Templates Through Config Files

Andrew Wilson — Wed, 03 Sep 2025 00:00:00 +0000

Overview

Building on our previous exploration of Typed Variables, today we’re diving into one of my favorite patterns for creating maintainable and reusable Bicep templates: the Shared Variable File Pattern. This approach transforms your templates from being tightly coupled to specific configurations into truly agnostic, environment-ready solutions.

The beauty of this pattern lies in its simplicity - by extracting configuration data into external JSON or YAML files, you can create templates that adapt without modification. When combined with typed variables, this approach becomes even more powerful, providing compile-time validation and enhanced developer experience.

Bicep Tips and Tricks | #7 | From Static to Dynamic Config

Andrew Wilson — Wed, 27 Aug 2025 00:00:00 +0000

Overview

One of my core goals when writing IaC templates is ensuring reusability of common components, resources, and in this case, configuration. More often than not, I see configuration that is broadly common between resources (except for one or two properties) being duplicated throughout templates. This duplication means that changing a single property value requires updates across the entire codebase—a change that’s not trivial to manage unless you’re well-versed with the codebase and understand all areas where the configuration is implemented.

Bicep Tips and Tricks | #6 | Typed Variables

Andrew Wilson — Wed, 20 Aug 2025 00:00:00 +0000

Overview

In late May this year, an exciting but semi overlooked feature was released, and I absolutely love it - Typed Variables!

Prior to this release, variable types were inferred through the value, which is fine for most statically defined content within a template, but there are cases that I will go through in this post where typing your variables really does make a big difference.

Why Use Typed Variables

Before I get going, let me walk through why you should consider using typed variables:

Bicep Tips and Tricks | #5 | From Documentation to Deployment-Time Validation: Conditional Parameter Requirements

Andrew Wilson — Wed, 13 Aug 2025 00:00:00 +0000

Overview

In Bicep templates, we sometimes encounter scenarios where certain parameters should be mandatory based on the value of another parameter. For example, when deploying to production environments, you might require additional configuration parameters that are optional for development environments.

One of the common ways in which I have seen this handled is through documentation, which can lead to deployment failures and inconsistent configurations across environments. This post explores how to implement fail-fast validation using Bicep’s built-in capabilities to enforce these conditional requirements at deployment time.

Bicep Tips and Tricks | #4 | Shared Variables

Andrew Wilson — Wed, 06 Aug 2025 00:00:00 +0000

Overview

This week is a simple one, but works wonders in maintainability and consistency.

There are often cases where you will need to define static values that don’t change frequently, if at all, and more importantly, you seem to be setting these up frequently for multiple templates. Here are some examples that I have seen:

Multi-Environment Deployments

Different environments (dev, staging, prod) that share common configuration but need environment-specific values:

Bicep Tips and Tricks | #3 | Naming Convention and Functions

Andrew Wilson — Wed, 30 Jul 2025 00:00:00 +0000

Overview

One of my bugbears is seeing either a complete lack of naming conventions or manual naming mechanisms that introduce human error through mistakes and misunderstandings. Naming conventions are incredibly important, but equally critical is how they’re implemented and maintained. Let’s explore a better approach.

What is a Naming Convention and Why Do We Need One?

A naming convention is a set of rules for naming Resource Groups and Resources (among other Azure components). These rules define the structure and composition of names, ensuring clarity, consistency, and compliance with Azure naming requirements such as length limits, valid characters, and scope uniqueness.

Bicep Tips and Tricks | #2 | Centralize Core Parameters with Types, Constructors, and Imports

Andrew Wilson — Wed, 23 Jul 2025 00:00:00 +0000

Overview

When building IaC templates we strive to enable them to be environment agnostic, configurable even. One of the mechanisms that we do this is through lots of “Core Parameters” that disseminate the fundamental details of our deployment and resources. The number of core parameters is often variable but the verdict is always true, three or more usually does the trick. These Core Parameters are passed into the main deployment template and any other sub deployment template (Module) too. These may include but are not limited to:

Bicep Tips and Tricks | #1 | Template Versioning and Applying to Azure Resource Tags

Andrew Wilson — Wed, 16 Jul 2025 00:00:00 +0000

The first of many

For those who know me well, starting a bicep tips and tricks series would not be a surprise to them. The moment the Bicep language was introduced, I knew I would be completely obsessed. I love writing bicep templates and even more the clever refinement to make them reusable, configurable, manageable, readable… I really enjoy sharing my experiences with Bicep, so here it begins on the wider front. From one Bicep nerd to another, I hope you find these tips useful, happy templating!

Automating web.config Environment Transforms in Azure DevOps Pipelines for App Services

Andrew Wilson — Wed, 02 Jul 2025 00:00:00 +0000

Background

Modernising legacy applications is always a journey, and recently I tackled moving an existing WCF web service into Azure App Service. If you’ve worked with WCF, you’ll know the web.config file is the nerve centre, handling everything from parameters to connection strings.

But here’s the catch, this service needs to run in multiple environments (Development, Test, and Production) each with its own unique settings. That means multiple config files:

How to Set Up Manual Approval for Azure App Service Slot Swaps in Azure DevOps Pipelines

Andrew Wilson — Fri, 06 Jun 2025 00:00:00 +0000

Overview

Deploying updates to production environments demands both speed and control. Azure App Service deployment slots, combined with Azure DevOps pipelines, offer a powerful way to manage releases, enabling teams to validate changes in a live-like environment before they go public. However, ensuring that only reviewed and approved changes reach your users is critical for maintaining reliability and compliance.

Azure App Service Slots unlock powerful advantages:

Site Review. Preview and test your site before it goes live, ensuring everything works as expected.
Warmed-up Instances. Swap with confidence. Your instances are pre-warmed, so there’s no downtime, seamless traffic redirection, and zero dropped requests.
Instant Rollback. If something goes wrong after a swap, simply swap back to restore your last known good version in seconds.

Best of all, deployment slots come at no extra cost. Check the Azure App Service limits to see how many slots your App Service Tier supports.

Agent Loop | Azure Logic Apps Just Got Smarter

Andrew Wilson — Wed, 21 May 2025 00:00:00 +0000

Microsoft Announcement

Microsoft has just introduced something quite revolutionary into the world of integration: Agent Loop, a new capability in Azure Logic Apps that lets you build AI-powered agents directly into your workflows. On the surface, it might seem like another incremental feature. But dig a little deeper, and the implications are huge!

Let’s break it down.

What Is Agent Loop?

Agent Loop is Microsoft’s way of embedding advanced AI decision-making into Logic Apps workflows. Think of it like adding a smart co-pilot into your integration flows, an agent that can retain context, reason over time, and take meaningful actions. It uses an LLM like Azure OpenAI under the hood, paired with a memory store that persists throughout the workflow, allowing the agent to understand, adapt, and make decisions across multiple steps.

The Requirements Ambiguity Paradox

Andrew Wilson — Fri, 16 May 2025 00:00:00 +0000

The Requirements Ambiguity Paradox

With the context of software requirements, I regularly encounter an understood but often ignored scenario: the less detailed the initial requirements, the more expansive the client’s expectations become as the project progresses. It’s a phenomenon I refer to as the Requirements Ambiguity Paradox.

Imagine initiating a project with a brief requirements document, aiming for agility and speed. At first glance, this seems efficient.

However, this brevity often leads to divergent interpretations:

Automating Semantic Versioning in Azure DevOps CI/CD Pipelines with GitVersion

Andrew Wilson — Wed, 07 May 2025 00:00:00 +0000

Overview

Versioning is the unsung hero of software development—often overlooked but absolutely essential. Imagine trying to manage a project without a clear way to track changes, communicate updates, or ensure compatibility. Chaos, right? That’s where versioning steps in, providing structure and clarity.

In this post, I’ll share how I streamline versioning in my projects by combining the power of Semantic Versioning (SemVer) with GitVersion, an automation tool that eliminates the manual effort of version management. Whether you’re just beginning your journey or tackling the complexities of feature-rich projects, this post will show you how to automate semantic versioning in Azure DevOps for consistency, traceability, and peace of mind.

Bicep | Existing Resource Dependencies

Andrew Wilson — Wed, 26 Mar 2025 00:00:00 +0000

Background

The Bicep existing keyword is a powerful capability that allows us to reference a resource that wasn’t deployed as part of the current Bicep file.

One of the typical use cases that I often see is where a resource is deployed as part of a module called by the parent template, the resource that was deployed as part of the module is then required later in the parent template and therefore an existing resource definition is used. As part of the template configuration there would be an explicit dependency between the existing resource definition and the module reference.

Logic App | Access Key Revocation and Regeneration

Andrew Wilson — Fri, 28 Feb 2025 00:00:00 +0000

Overview

In previous articles I have subtly referenced risks and best practices regarding HTTP triggered workflows and their use of Access Keys for security, such as:

Some Potential Risks:
- If a Key is leaked, it can be used by anyone who obtains it to call your Logic App Workflow.
- If a Key has expired or been invalidated then services, applications, and or users who have not been provided a new key will cease to be able to invoke your workflow.
Some Access Key Best Practices to mitigate risks:

Logic App | Try-Catch Pattern, Nested Scopes, And Compensating Transaction Pattern

Andrew Wilson — Wed, 08 Jan 2025 00:00:00 +0000

The Try-Catch Pattern

Following the idea of defensive programming or as I like to call it for Logic Apps (being low code): defensive processing, it is considered good practice to wrap your workflows in a try-catch pattern to handle the unexpected. The pattern makes use of a mixture of Run After conditions and the Scope block.

Run After Conditions | used to define the execution order based on the state of the previous action or scope
Scope Block | provides the ability to group a series of actions. If any action within the scope fails, the whole scope will fail (unless handled via other means)

By placing your actions within a “try” scope with the assumption that each action will run after the success of the previous, if there is an action failure, the scope will fail also.

Key Vault Reference | Logic and Function Apps using User-Assigned Managed Identity

Andrew Wilson — Mon, 06 Jan 2025 00:00:00 +0000

Overview

Prior to the Christmas break I was involved in writing some integrations that used a mixture of Logic Apps Standard and Function Apps. It was agreed as part of the architecture that user-assigned identities would be the best fit. As part of the implementation, I observed that the differences in configuration setup between system-assigned and user-assigned wasn’t widely understood. This article aims to show a brief run through of both.

Easy Auth | Standard Logic App with Azure API Management

Andrew Wilson — Tue, 26 Nov 2024 00:00:00 +0000

Overview

The recent work that I have been doing with Standard Logic Apps and linking them as backends to Azure API Management has relied on the use of the Logic App Workflow SAS key for security. This is a valid authentication approach, but there are risks that you need to be aware of as well as best practices that you need to be abiding by. Such as:

Some Potential Risks:

Easy Auth | Function App with Azure API Management

Andrew Wilson — Thu, 14 Nov 2024 00:00:00 +0000

Overview

The recent work that I have been doing with Function Apps and linking them as backends to Azure API Management has relied on the use of the Function Apps Function SAS key for security. This is a valid authentication approach, but there are risks that you need to be aware of as well as best practices that you need to be abiding by. Such as:

Some Potential Risks:

Azure API Management | Function App Backend

Andrew Wilson — Tue, 01 Oct 2024 00:00:00 +0000

Overview

Following on from a previous set of posts from earlier this year where I detailed how to securely implement Logic App Standard backends in Azure API Management, there has been questions on how this would be achieved in a similar manner with Azure Function Apps.

To read-up on how this was achieved with Standard Logic Apps have a look at the following:

At a high level comparison with Azure Logic Apps, Azure Functions are a developer-centric serverless compute offering allowing authors to write code in languages such as C#, Java, Javascript, Python, and PowerShell. Azure Functions are best suited for stateless computation and application specific tasks.

Speaking | Azure Security Do's and Don'ts: A Developer's Checklist for Secure Azure Applications

Andrew Wilson — Thu, 15 Aug 2024 00:00:00 +0000

I recently had the privilege to be hosted on the Azure on Air podcast by the Turbo360 team. I had a great conversation with Lex discussing the importance of a “security first” mindset in the world of Azure solutions, and how this mindset should be carried out as a priority in every stage from Requirements Gathering, Design, Development, and Release.

During our time together we discussed topics such as:

webpack | Build Time Environment Variables With Azure DevOps Yaml CI/CD

Andrew Wilson — Thu, 25 Jul 2024 00:00:00 +0000

Problem Space

One of my recent projects has involved the use of a static module bundler called webpack to bundle a typescript site so I can serve static content from a Static Web App in Azure.

For a while now the site content has not deviated between environments [ dev / test / prod ] and therefore we have simply built and bundled the site for deployment.

Recent changes however have required that there be some deviation between environments, at which point the question raised, at what point should this deviation be set or retrieved?

Azure Role Based Access Control (RBAC) | Removing Orphaned Role Assignments

Andrew Wilson — Thu, 04 Jul 2024 00:00:00 +0000

Problem Space

Deploying solutions into Azure that rely on Role Based Access often involve us creating IaC automation for the assignment of roles, such as:

A services access to Key Vault
A services access to a Key Vault specific secret
A services access to a storage account
A services access to a Service Bus Queue or Topic

In many of these instances we may wish to leverage the source resource identity (System Assigned Managed Identity) for the assigned access.

Azure API Management | Enable Tracing for an API

Andrew Wilson — Sun, 02 Jun 2024 00:00:00 +0000

Background

For a while now I have made good use of the Trace functionality in the API Management (APIM) Test Client. If you haven’t, I would highly advise having a look. The Trace functionality allows us to unveil (debug) the complexity and inner workings of our reverse proxy APIs (their routing / hierarchical policies / alternate backends / caching / etc.). With the Portal this is fairly trivial to do, you simply:

Bicep | Prevent a Nasty Refactor with Function Namespaces

Andrew Wilson — Mon, 27 May 2024 00:00:00 +0000

Problem Space

Azure API Management | Unintentional Removal of Request Forwarding to Backend

Andrew Wilson — Fri, 03 May 2024 00:00:00 +0000

Problem Space

I have recently been working on an API scoped policy within API Management, the policy ideally should not be impacted by any policies defined higher up in the hierarchy.

For reference, this means that any policies defined at the Product, Workspace, or Global level will not be inherited at the API scope for the given API Definition. See diagram below:

Ideally this means that my API traffic will start at my non-hierarchical policy definition, conduct any policy processing prior to being sent off to the backend, and then sent back to the calling outbound system.

Azure API Management | Governing Product Visibility and Access via Groups

Andrew Wilson — Tue, 30 Apr 2024 00:00:00 +0000

Overview

In API Management, users and groups are a core aspect of the Developer Portal and are used to manage the visibility and access to respective products and their APIs.

One of the common questions that I often get asked is, “how do I appropriately govern the groups effectively so that I can ensure that the correct groups and users have access to the appropriate resources and those who don’t… well don’t?”.

Microsoft.Web/Connections | Access Policies

Andrew Wilson — Wed, 10 Apr 2024 00:00:00 +0000

Problem Space

I have recently been adding email alerting to some Logic App Standard workflows as part of the error handling flow. In doing so I made use of an existing Office 365 Outlook Connector in the Azure Subscription; the connector is not built in for Standard Logic Apps but is rather part of the Managed Api Connections.

Managed Api Connectors require more than just the connection details to be detailed in the Logic Apps connections.json configuration as shown below:

Bicep | User Defined Types

Andrew Wilson — Wed, 07 Feb 2024 00:00:00 +0000

Problem Space

Over the years of developing Infrastructure as Code (IaC) with either ARM templates or Bicep (since it was released in 2020), I have made it my best practice where possible to use well-defined base type parameters (Strings | Integers | Booleans) so that the templates are usable and maintainable by collaborators apart from myself. This usually equated to where possible avoiding the use of Object and Array parameters, although in many cases the use of these types was inevitable given the complexity of the infrastructure and resources being deployed.

Azure API Management | Logic App (Standard) Backend Using a Swagger Definition

Andrew Wilson — Thu, 01 Feb 2024 00:00:00 +0000

Overview

After setting up a Logic App (Standard) Backend in Azure API Management (APIM) in my last post, I wanted to try and see if I could create a Swagger definition from a Standard Logic App which could then be used to simplify the API authoring process in APIM. This post shows my methods of doing so.

If you haven’t already I would recommend reading my previous post as this one will be working off of the building blocks of the last.

Azure API Management | Logic App (Standard) Backend

Andrew Wilson — Tue, 02 Jan 2024 00:00:00 +0000

Overview

Updated [31/01/2024]: See New Post showing methods of linking a Logic App Standard as a Backend to APIM through a Swagger Definition.

I have recently been reviewing the method in which a Logic App (Standard) workflow would be setup as an API in API Management. My aim is to overcome and simplify the limitation whereby directly importing a Logic App (Standard) workflow is not available, only in consumption.

Windows Terminal | Azure Customisation for PowerShell

Andrew Wilson — Thu, 30 Nov 2023 00:00:00 +0000

If you haven’t already, placing a customisation on your command prompt for PowerShell is a great way to gain extra context in given activities. For example, if you would like to have a comprehensive overview of your Git status summary information, then posh-git is for you.

Be Careful: Adding customisations will bring latency to start-up

One customisation that I came across that I really like is the cloud-native-azure theme using Oh My Posh. The theme gives context to the following:

Azure RBAC Key Vault | Role Assignment for Specific Secret

Andrew Wilson — Wed, 22 Nov 2023 00:00:00 +0000

Background

Azure role-based access control (Azure RBAC) provides fine grained control over access to Azure resources. Azure RBAC is founded on top of the Azure Resource Manager which allows us to provide access authorisation at differing scope levels ranging from the Management Group through to individual resources.

With RBAC enabled key vaults we can manage access to the resource and data stored in the vault. We can also manage access for individual keys, secrets, and certificates.

Azure API Management | Unintentional Pass through of Subscription Key Header

Andrew Wilson — Tue, 21 Nov 2023 00:00:00 +0000

Problem Space

There is a potential unintentional side effect when you add a APIM subscription key as a header to an inbound request. The header is not stripped from the request prior to being sent to the configured backend service. Rather it is retained.

If you manage the backing service and are not concerned with the disclosure of the subscription key, then no problem. However, being overly permissive of this information may make your API more vulnerable to security threats and disallows a separation of concerns.

Desired State Configuration | Project DSC

Andrew Wilson — Mon, 23 Oct 2023 00:00:00 +0000

Problem Space

I have often found myself with a peeked interest into any method that will simplify both the on-boarding and return to a given project.

Why the interest you may ask…

Well, in most cases when working on a given project (Greenfield or Brownfield), one member of the team will scout ahead to make sure all the engineering tasks are complete. This often allows the development team to work in parallel without stepping on each others toes or be reclined to a halt due to engineering tasks that can only be conducted by a smaller subset of the team. These tasks often include:

BizTalk | Replacing Strong Name Keys

Andrew Wilson — Wed, 28 Jun 2023 00:00:00 +0000

Background

Strong Names provide .NET Framework assemblies with unique identities. When the .NET Framework loads a strong-named assembly for a referring assembly, it verifies the strong name signature. If the strong name signature of the assembly cannot be verified, the .NET Framework will not load the assembly.

!Do not rely on strong names for security. They provide a unique identity only!

Alternatively in our case, BizTalk assemblies are loaded into the Global Assembly Cache (GAC). In this case, instead of the .NET Framework verifying the assembly identity each time it requires loading, the assembly identity is verified once when installed into the GAC.

BizTalk | Deploying and Reading Secure SSO Settings

Andrew Wilson — Wed, 26 Apr 2023 00:00:00 +0000

Background

One of the fundamental parts to BizTalk for both configuration and integration applications is Enterprise Single Sign On, or as we will continue to reference as SSO from now on.

SSO outside the bounds of BizTalk is an available service that is used to store and transmit encrypted user credentials. However, due to the nature of the service it is fairly generic, this has meant that many middleware applications and custom adapters have been designed to leverage SSO to securely store and transmit secure settings.

Bicep | Deployment Scope Hopping

Andrew Wilson — Tue, 25 Apr 2023 00:00:00 +0000

Background

An Azure Tenant is hierarchically structured with the following make up:

Tenant
One or more Management Groups
One or more Subscriptions
One or more Resource groups
One or more Resources

Deployment Scopes {Tenant, Management Group, Subscription, Resource Group} allow us to deploy respective types of resources at each level.

A Scope is dictated by two attributes, the selected scope level, and the identifier of the item at that scope level. For example, if I am to deploy at the Subscription Scope, I need to both Identify that I am doing a Subscription Deployment, and I need to provide the identifier of the Subscription. Resource Groups are the lowest in the list of Scope Levels.

Bicep | Conditional Iterative Deployment

Andrew Wilson — Tue, 11 Apr 2023 00:00:00 +0000

Background

I have recently been looking at creating multiple of the same resource using Bicep. There is however a condition where I would wish for the set of resources not to be deployed. The following stages show my work through of this particular problem (using a storage account resource as an example):

Conditional Deployment

Conditional Deployment is used where you may or may not wish to deploy a given resource depending on the outcome of a given condition (if statement).

Bicep Template | Shared Variable File Pattern

Andrew Wilson — Wed, 08 Mar 2023 00:00:00 +0000

Background

I have recently been playing around with some of the Bicep functions when I came across a pattern by Microsoft called the Shared Variable File Pattern.

This nifty pattern describes a method in which you can extract what would either be commonly used or complex configuration values away from your Bicep Template. Using the pattern will allow you to retain easy to read and manageable Bicep templates where you have modelled large variable configurations and or configuration values that are used repeatedly across your templates (prevents multiple copies of the value that would need to be maintained).

Automating Deployment of Azure Consumption Logic Apps | Bicep and ARM

Andrew Wilson — Fri, 24 Feb 2023 00:00:00 +0000

Azure Logic Apps

Azure Logic Apps is an Azure Integration Service (AIS) that provides you the ability to create and run automated workflows with little to no code. Consumption Logic Apps are developed using the visual designer within the Azure Portal.

If you are new to developing Azure Logic Apps, there is great Microsoft Learning material to get you started:

What are Azure Logic Apps | https://learn.microsoft.com/en-us/azure/logic-apps/logic-apps-overview
Introduction to Azure Logic Apps | https://learn.microsoft.com/en-us/training/modules/intro-to-logic-apps/
Quickstart: Create an integration workflow | https://learn.microsoft.com/en-us/azure/logic-apps/quickstart-create-first-logic-app-workflow

Problem Space

Once you have created your workflow in the Logic App designer, your next question may be:

Fluent UI | React | Controlled multi-select Dropdown - Selected Keys

Andrew Wilson — Mon, 13 Feb 2023 00:00:00 +0000

Problem Space

I ran into a problem the other day working with the Fluent UI React component Controlled Multi-select Dropdown. As context, here is my redacted code and explanation:


import { Dropdown, IDropdownOption } from 'office-ui-fabric-react'; // office-ui-fabric-react@7.204.0

export interface State {
 itemList: IDropdownOption[];
 selectedItems: string[];
}

export default class DropDownExample extends React.Component<any, State> {
 constructor(context) {
 super(context);
 this.state = {
 itemList: [{ key: 'None', text: 'None' }],
 selectedItems: []
 }
 this.GetItems();
 this.LoadPreselection();
 }

 private async GetItems(){
 // ... load items into itemList
 }

 private async LoadPreselection(){
 // ... load pre-selected items into selectedItems
 }

 public onItemChange = (event: React.FormEvent<HTMLDivElement>, item: IDropdownOption): void => {

 if (item) {
 let tempItemsArray = selectedKeys;
 const index = tempItemsArray.indexOf(item.key, 0); // Obtain item index if exists - returns -1 if it does not

 if (index > -1) {
 tempItemsArray.splice(index, 1); // If the item exists, remove the item from the existing array through the splice function
 } else {
 tempItemsArray.push(item.key); // If the item does not exist, add the item to the existing array
 }

 setSelectedKeys(tempItemsArray); // Update State
 }

 }

 render() {
 return (

 ...

 <Dropdown
 placeholder="[Select Item]"
 disabled={this.state.itemList.length === 0}
 label='Items'
 id='items'
 responsiveMode={1}
 multiSelect
 options={this.state.itemList}
 selectedKeys={this.state.selectedItems}
 onChange={this.onItemChange.bind(this)}
 />

 ...

 );
 }
}

I had a list of items that I wanted to load into the Multi-select control from an API call. After obtaining the list of items, I wanted to preload any previously selected items.

Azure DevOps Pipeline | Git Shallow Fetch

Andrew Wilson — Mon, 09 Jan 2023 00:00:00 +0000

Problem Space

I have been recently working on building a new Yaml pipeline in Azure DevOps and wished to use the GitVersion Task, however, upon running the pipeline the task failed with the following error:

ERROR [../../.. ..:..:..:..] An unexpected error occurred:
System.NullReferenceException: Object reference not set to an instance of an object.

After some digging and a conversation with one of my colleagues, it turns out there has been a change on Azure DevOps pipelines. By default now when a pipeline is created, the ‘Get Sources’ Shallow fetch setting is enabled and set to a depth of 1.

Bicep | File Reference in a Git Repository Containing Spaces

Andrew Wilson — Fri, 06 Jan 2023 00:00:00 +0000

Problem Space

I recently started working on a Git Repository (not of my own creation) that had a repository name containing spaces.

As a helping hand when a repository is created with spaces in the name, the spaces are replaced with %20 when cloned … Unless otherwise specified, however, this would then need to be specified whenever another user/pipeline clones the repo. See the git command below:

git clone https://.../.../my%20repo myrepo

My best practice answer would be, don’t create repositories with names containing spaces, but this one already did.

Azure Storage Account | Deletion and Reuse

Andrew Wilson — Thu, 05 Jan 2023 00:00:00 +0000

Problem Space

When it comes to creating Azure Storage Accounts, the name has some very important rules that need to be kept in mind. These rules will not only be important in the creation of the resource, but will be critical in deletion and reuse.

The rules are as follows:

Storage account names must be between 3 and 24 characters in length and may contain numbers and lowercase letters only.
Your storage account name must be unique within Azure. No two storage accounts can have the same name.

Azure API Management | Product Required Subscription Behaviours

Andrew Wilson — Tue, 20 Dec 2022 00:00:00 +0000

Background | Functional Workings of APIM Subscriptions

Subscriptions are a nice and easy method of securing your APIs in APIM, however as I bumped into a small detail around their use the other day, I thought it wise to note it down.

Azure API Management Subscriptions operate at three scope levels:

All APIs
- Applies to any API that requires a Subscription.
- As this will allow access to ANY api, use this with caution.
Specific APIs
- These subscriptions are linked to specific APIs, and their keys can only be used by those APIs.
- An API with a Specific subscription, as mentioned above, can be called with a generic All APIs Subscription Key.
Products
- Products are independent of APIs and therefore have their own ‘Subscription Required’ setting and behaviours. See Problem Space below.

Problem Space

As mentioned above, because Products are independent of APIs, their subscriptions operate slightly differently and can cause some ill effects if unknown.

Azure API Management | Subscription Contract Names

Andrew Wilson — Tue, 20 Dec 2022 00:00:00 +0000

Problem Space

Subscriptions are a nice and easy method of securing your APIs in APIM, however as I bumped into a small detail around their use the other day, I thought it wise to note it down.

When a Subscription Key is required on an API, as an invoker I will need to provide either a Header or a Parameter to my request which will contain the Subscription Key.

By default:

Bicep File Template | VS Code Snippet

Andrew Wilson — Wed, 16 Nov 2022 00:00:00 +0000

Problem Space:

After developing native ARM templates for a year or two within a set structure, I have found myself applying the same structure to my Bicep templates using comments. This structure however is not setup by default, and in actuality, the sequencing of your bicep components doesn’t really matter as long as your dependencies are there.

Of course we typically follow the standard pattern as shown below, but the larger the template the harder it is to see the breaks between.

Azure API Management | API Mocking

Andrew Wilson — Sun, 18 Sep 2022 00:00:00 +0000

Problem Space:

I have been recently looking into setting up some APIs within API Management. I do not currently have any backing services to hook the API’s to and I would like to decouple development of the front end systems from the backend. Thankfully Azure API Management has provided the ability to create mocks for your API’s. In this post I will be walking through API mocking and how to achieve this within Bicep Templates for deployment.

Azure API Management | Purge Soft-Deleted Instance

Andrew Wilson — Wed, 07 Sep 2022 00:00:00 +0000

Problem Space:

Around June 2020 a change was made to Azure API Management whereby any deletion of the instance via the Azure portal, Azure PowerShell, Azure CLI, and REST API version 2020-06-01-preview or later will result in the instance being soft-deleted.

This is to allow for recoverability of a recently deleted API Management instance, and therefore protecting against accidental deletion of the instance.

The problem with this is that not all the Azure Resource Management tooling currently supports the management of soft deleted API Management Instances. Currently the only management tooling that supports this feature are the REST API and Azure CLI. You cannot at this point in time list, show, or purge a soft deleted instance in the Management Portal or Azure PowerShell.

Azure Logic App | Parallel Terminates & Action State Checking

Andrew Wilson — Sun, 04 Sep 2022 00:00:00 +0000

Problem Space:

I have recently encountered an interesting problem space with Azure logic app action run after logic. I ran into the problem whilst creating a logic app that will perform actions in parallel. The bulk of the actions are performed in scopes. If an action fails within the first set of scopes, the scope status is Failed. If the first scope fails, then the second scope full of actions are executed (this based on run after logic). The problem with this is that I still need the logic app to terminate as Failed so that an alert will be fired off.

Azure Role Assignment

Andrew Wilson — Fri, 02 Sep 2022 00:00:00 +0000

Problem Space:

I recently came into some issues with assigning Azure roles through a Bicep template and pipeline deployment. I was looking to assign ‘Storage Blob Data Reader’ to a service principal, and refine their access to only the container of the storage account. The three main issues that I ran into were:

What are Role Assignment Conditions and how can I use them in my template?
I am trying to assign a built in role, what is the roleDefinitionId that I should be using?
I am trying to assign the role to a service principal user, what id should I be referencing in the template?

For reference, the Bicep template for role assignment¹ that I am using is shown below: