The matrix strategy in Azure DevOps pipelines allows you to run the same job multiple times using different variable-sets. Instead of creating separate jobs for each variable, you define a single job and a matrix of configurations, and the pipeline automatically creates one job for every combination.

Over time, branches accumulate, they get merged, abandoned, or deleted remotely but still present locally.

Short on time? Here’s the TL;DR:

git fetch --prune          # Sync + remove deleted remote branches
git branch -vv             # Find stale branches ([gone])
git branch -d branch_name  # Delete them safely

Recently, I ran into a frustrating issue with a shell script that uses heredocs. The closing EOF had indentation, so the shell didn’t recognize it as the closing tag. Everything after it kept getting added to the file, breaking the whole thing and the logs were showing this warning: here-document at line 1 delimited by end-of-file (wanted 'EOF') warning.

Moving from software development to DevOps means the terminal is no longer just for Git commits; it’s your primary interface for production infrastructure. This guide categorizes the 20 most critical commands by their real-world utility.

Helm is a package manager for Kubernetes that helps you define, install, and upgrade applications using charts (templates and configurations).

The error Error: must either provide a name or specify --generate-name occurs in Helm v3 when you run helm install without specifying a release name. The release name is a unique identifier for that installation—Helm requires it to track and manage your deployments.

Azure Pipelines support two types of expressions to control pipeline behavior: compile-time expressions (evaluated at pipeline creation) and runtime expressions (evaluated during pipeline execution). Template expressions, a subcategory of compile-time, help you create reusable pipeline components.

The key takeaway: Use compile-time expressions with parameters for fixed values needed at pipeline creation, and runtime expressions with variables for dynamic behavior based on execution state.

Want to dive deeper into all this terminology? Read along to learn all the details.

When working with regular expressions in PowerShell, capturing groups allow you to extract specific parts of a matched pattern. However, there are two important syntax considerations when referencing these groups in your code.

But first, let us understand what a capturing group is.

When working with Azure Pipelines, you may need to access a repository and reference its code from a specific feature branch instead of the default branch. I am dealing with this scenario almost everyday and the most common case is testing changes made on a feature branch, before they’re merged to the main branch.

When working with Azure Bicep, you can safely reference an existing Azure resource using the existing keyword. This eliminates the risk of unintended modifications or deletions.

Here’s the syntax to retrieve an existing resource:

When working with Azure Pipelines, the checkout keyword is typically used to reference a Git repository with a fixed name. For example in your Azure Pipeline you will add the following line:

- checkout: git://MyProject/MyRepository

While this works well for static scenarios, what if you’re working with multiple repositories? For instance, when automating tasks that iterate over a list of repositories, hardcoding each repository name becomes inefficient and error-prone.

When working with Azure DevOps pipelines you will often want your tasks to run PowerShell scripts. Since the execution of the upcoming tasks can be dependent to the result of the current task, your script will have to inform about success or error.

For this task you can use exit codes, which indicate the success or failure of a command or script. We are also going to learn how to use the $LASTEXITCODE variable to determine the outcome of your commands.

When working with Azure Pipelines, you may encounter a situation where you don’t know the repository name before the pipeline runs. In such cases, using the checkout: git://MyProject/MyRepo method won’t work, as variables can’t be used as values in that syntax.

You will get the following error from Git:

fatal: Cannot prompt because terminal prompts have been disabled.
fatal: could not read Password for 'https://[email protected]/...': terminal prompts disabled

To overcome this challenge, I came up with a solution: create a task at the beginning of your job definition that “authenticates” the pipeline against your Azure DevOps project.

Let’s see this in action.

Puppeteer Sharp is a website crawler for C#. I personally use it to crawl websites for price information of products that I am interested in. In this article, you are going to learn about the configurations you have to do if you want to use the crawler in a Linux hosted web application.

Consider the following real-life application scenario. Your Web App (Azure App Service) accesses a CosmosDB instance to read data. Your users access the web application from its UI, and you want to ensure they cannot directly access the CosmosDB instance using its public URL.

In this article, you will learn:

• How to use a System Managed Identity and RBAC roles to access your CosmosDB instance from your Web App
• How to integrate your Web App and your CosmosDB with an Azure Virtual Network
• How to create a Service Endpoint to allow only the Virtual Network to access CosmosDB
• All the necessary az CLI commands to complete the tutorial, without using the Azure Portal UI :)

In this article, I will show you a full tutorial on how to create a .NET application using Angular for the frontend and deploy this application with Azure DevOps pipelines on multiple App Service environments.

You are going to learn:

• How to use pipeline templates to simplify the structure of our pipeline
• How to use multiple stages to split semantically different jobs
• How to use multiple Azure environments by elevating the power of a for loop in the pipeline
• How to use Bicep for setting up the needed Azure infrastructure
• How to deploy the application on an Azure App Service by using different deployment slots

You can find the code for this tutorial on my GitHub account.

Consider the following scenario in Azure:

• We want to create a new Azure Function triggered by an HTTP request containing some data.
• We want to write this data as new entities into a Storage Table.
• We want to avoid storing any connection string in your code and instead use an Entra ID Managed Identity.
• We want to avoid writing any specific code by using the SDK for accessing the Table.

The TableOutputAttribute comes to the rescue. Let us see how.

Azure Key Vault is a cloud service that provides secure storage for secrets, keys, and certificates of your applications. Integrating Key Vault with Azure DevOps pipelines enhances security by managing sensitive information efficiently.

This article will guide you through the process of accessing secrets from an Azure Key Vault using a Service Principal with a certificate within an Azure pipeline. We will start for the very first steps of creating all the needed resources in Azure, before going back to Azure DevOps. For training reasons, we will perform all the configuration steps with CLI commands, avoiding the Azure Portal UI.

I recently wanted to configure the CI/CD process in Azure DevOps of a new application I created and wire it with my Azure account so that the application will be deployed on an App Service. A missing user permission in the project settings was the problem. Lets see the steps to solve the error.

Bicep, a domain-specific language (DSL) for deploying Azure resources, simplifies the process of writing infrastructure as code. However, like any programming language, it has its own set of rules and syntax that must be followed. One common error that developers encounter is the BCP001 error, which occurs when Bicep encounters an unrecognized token.

An iterator in C# is a method that utilizes the yield keyword to return elements one at a time to the caller. Such methods are very useful for traversing collections, without needing to create an intermediate collection inside the method for storing results.

This article will help you understand how to use yield by using practical examples.

When working with multiple repositories in an Azure pipeline, you might need to access a PowerShell (.ps1) function from one repository while running your pipeline in another. Here’s a straightforward guide to make that happen:

When practicing continuous integration and continuous deployment (CI/CD), optimizing build, test, and deploy times becomes crucial. GitLab, a popular platform for managing CI/CD pipelines, offers several strategies to speed up your workflows. Let’s explore some tricks you can use to accelerate the entire process.

Microsoft Azure DevOps provides a solid way of tracking your team-progress while using the scrum principles.

Nuget Packages with WebApi Clients are provided for accessing your team information via code. For example you can access the queries of your team, the work items of your backlog and much more!

In this article we will focus on getting the capacity of the current sprint for each member of your team. This is the code snippet that does our job:

Azure Functions are compact and lightweight chunks of code hosted in Azure cloud and can be accessed via HTTP. Since these functions might access sensible data of your application, you want a safe way to call them.

When you are in the development phase, you can use the Host Keys which is a way of authenticating yourself when calling an Azure Function.

When in production, you will have to change to App Service Authentication, since the Host Keys should not be stored in the client’s machines.

In the previous article we focused on building the Continuous Integration Pipeline of our hello-world Vue app.

In Part 2 we are going to do the steps for deploying the result of the CI Pipeline to Azure. From there our static website is going to be visible to the rest of the world.

Here are the steps you will have to take:

While I have some extra free time because of the Corona virus outbreak, I decided to experiment with Vue and build a small static HTML Hello-World application for getting to know the framework better. The website contains no backend code.

The article focuses on how to automate the Build and Deploy process of our small application. I will try to clarify the steps needed till our static website is visible through an Azure URL.

In this article I will skip the Vue logic of my app and focus solely on the DevOps tasks that have to be made in Azure DevOps. Our static website will then be deployed on an Azure Storage Container. The article focuses on Windows users.

Most of us use private feeds in NuGet for storing our NuGet Packages. However, some projects might have stricter security restrictions that others, making it necessary to disable certain feeds to avoid using them as references.

To “blacklist” feeds, you can use the following configuration:

Back in 2017, I wrote an article about how to program an Azure Function in Visual Studio. With the current article I want to give the current state of creating Functions, this time in Visual Studio Code.

We are going to create a GET Function that retrieves all the rows from an Azure Storage Table and returns them the caller.

Here are the steps from scratch:

Running an MSSQL Database inside a Linux Docker Container can be done for many reasons. You might want to host your dockerize your whole web application or even the DB part of it. When using such a Container you want to have an easy way to see the content of the Database. For that we can use the SQL Server Management Studio tool.

Lately I was setting up a web application inside a Docker. container which communicates via ODBC with a database. In order to be able to query the database, I had to add the name of the database and the credentials into the odbc.ini and odbcinst.ini files. My queries were failing with the following message: “ERROR [IM002] [unixODBC][Driver Manager]Data source name not found and no default driver specified”

When using web applications inside a Docker Container you might come across SSL certificates that have to be installed on the running Container. Things get a little bit more complicated when you want to install Windows certificates into a Linux Image. Following you can see the steps to achieve this task.

When working with “9 to 5” web applications you deal with idle time periods where the users submit few or no requests to specific services of your application. In that cases the first request landing to a service hosted on IIS will take much longer than usual because the service was in sleep mode for better management of resources.

We can avoid this behavior and keep our services in an always-running mode by applying the following three configurations in IIS:

While I was developing a .NET Core web application and wanted to automate the build process in VSTS, I got the following error, when I was triggering the build:

Error: Assets file ...\project.assets.json not found. Run a NuGet package restore to generate this file. Process 'msbuild.exe' exited with code 1.

The issue here is that needed .NET Core files are missing, when we start build our application. I solved this problem by defined an extra initial step in my build process.