- Articles

Using Managed Identities to access Azure SQL

Wed, 11 Jan 2023 13:08:00 +0000

Using managed identities to access SQL in Azure is a great way to up the security of your solution.

Running a Windows container with gMSA on a non-domain joined host

Mon, 05 Dec 2022 10:08:00 +0000

Using gMSA to let Windows containers run under a domain context can be really useful.

Using dotnet runtime package stores to optimize your docker images

Wed, 09 Nov 2022 10:42:00 +0000

.NET offers a somewhat unknown feature called “runtime package stores”, which can be used to optimize your Docker images.

Build the modular monolith first

Mon, 31 Oct 2022 08:42:00 +0000

Even talking about building a monolith today, is a bit taboo. It is all about microservices at the moment, and has been for a few years. But they aren’t a silver bullet…

Integration Testing ASP.NET Core APIs incl. auth and database

Mon, 10 Oct 2022 12:02:00 +0000

Automated tests are pretty awesome to be honest! They make life a lot simpler in many ways. And even if a lot of people are talking about how we need to do unit testing, I find integration testing much more valuable to be honest.

Infrastructure as Code - An intro - Part 7 - "Conclusion"

Thu, 09 Dec 2021 12:34:00 +0000

I’ve finally come to the “conclusion” part of my blog series about infrastructure as code. The part I thought was going to be the easiest one to write…

Infrastructure as Code - An intro - Part 6 - Using Pulumi

Thu, 18 Nov 2021 14:50:00 +0000

The 6th entry in my blog series about IaC is dedicated to Pulumi.

Pulumi is a very different beast, compared to the previously covered technologies (ARM, Bicep and Terraform), in that it is not based on a Domain Specific Language. Instead, Pulumi allows you to write your IaC in your language of choice. As long as your language of choice is JavaScript/TypeScript, Python, Go or .NET Core (C#, F# and VB). This makes the Pulumi experience a lot different from using a technology that uses a DSL (or JSON).

Infrastructure as Code - An intro - Part 5 - Using Terraform

Wed, 03 Nov 2021 16:01:00 +0000

In this 5th entry in my IaC blog series, I want to talk about Terraform.

Terraform is a bit different from ARM and Bicep, which I covered in the previous post, as it isn’t Azure specific. Instead, it enables the user to deploy resources not only to Azure, but also to a lot of other clouds/systems. This makes it a more flexible alternative that is very useful if you need to deploy a mix of resources, or potentially not target Azure at all.

Note: At the time of writing, there were 1515 different providers available for use with Terraform. For an up-to-date list, have a look at https://registry.terraform.io/browse/providers

What is Terraform

Terraform is one of several products from HashiCorp. Most of them aim to help out with cloud native application development.

In Terraform, resources are defined using the HashiCorp Configuration Language (HCL). By using this “neutral” language and depend on separate providers for resource provisioning and management, it can be used to target a very wide set of systems and clouds. And by making the provider implementation open for anyone to implement, it allows all kinds of vendors to provide Terraform users with custom functionality to target their specific environment.

In the case of Azure, the Terraform provider is built on top of the Go SDK for Azure. This unfortunately means that there is often a delay between new features being released and Terraform offering support for them. The reason for this is that when a new feature is made available in the Azure API, the Go SDK must add support for it before someone can go ahead and add the feature to the Terraform provider. In a lot of cases, it isn’t a problem if you have to wait for a new feature for a few weeks, but I do find it worth mentioning if you are currently evaluating what IaC tool you should use.

Infrastructure as Code - An intro - Part 4 - Using Bicep

Thu, 30 Sep 2021 15:07:00 +0000

In the last post, I talked about IaC using ARM templates. In this post, I’m looking at ARM templates’ “sibling” Bicep.

Infrastructure as Code - An intro - Part 3 - Using ARM

Wed, 22 Sep 2021 14:53:00 +0000

In this 3rd post in my series about IaC, it is time to move away from the imperative approach, and start looking at doing it declaratively. And for that, I have decided to start off by looking at Azure ARM templates.

Infrastructure as Code - An intro - Part 2 - Using Azure CLI

Wed, 08 Sep 2021 14:07:00 +0000

As I mentioned in my previous post, that there are a lot of tools out there for doing IaC. In this post, I want to show how to set up infrastructure in an imperative way using the Azure CLI.

Infrastructure as Code - An intro - Part 1

Thu, 02 Sep 2021 10:37:00 +0000

Infrastructure as Code is a really interesting concept! But what is it…really? Well, let’s have a look at it and see if we can’t make it less of a “sales pitch”. And maybe even make it a thing that you might want to have a look at for your next project! Or maybe even your current one…

Setting up ASP.NET Core dev certs for both WSL and Windows

Tue, 04 May 2021 13:13:00 +0000

A while back, I wrote this blog post about setting up ASP.NET Core dev certificates for both WSL and Windows. However, when running through the steps today, it didn’t work… So I decided to write an updated version that is a bit simpler, and works…

Using initContainers in Kubernetes

Wed, 28 Apr 2021 15:31:00 +0000

I’ve been considering writing a post about Kubernetes initContainers for a while, but for some reason I just haven’t gotten around to doing it… That’s about to change!

Don't let Entity Framework call the shots

Wed, 31 Mar 2021 15:31:00 +0000

With .NET Core, Entity Framework is the default choice when it comes to database access. And even though it definitely is a powerful beast that can do alot of things, it is also slightly complicated to use to be honest. I guess that is the reason that I keep seeing these really weird “EF patterns” being used in different projects… Most of these annoying “patterns” involve people replicating the database in the C# code, or writing code to fit EF instead of the other way around.

Azure Private Endpoints, Service Endpoints etc

Wed, 24 Mar 2021 14:48:00 +0000

There are quite a few things you need/should know when you start considering putting you Web App “into” your VNet. Or any Azure service for that matter… In my last post, Securing Azure Web Apps using Application Gateways and vNets, I explained how to set up a Web App behind an Application Gateway using Private Endpoints. However, there were so many things that I felt didn’t quite fit into that post. So I decided to write a more generic post on the topic.

Securing Azure Web Apps using Application Gateways and vNets

Fri, 05 Mar 2021 15:12:00 +0000

For the last many years, I have used Azure to run pretty much all of the workloads I have built. And deploying applications to Azure Web Apps has been an extremely common thing. However, I was recently tasked with hosting a few web apps on a vNet behind an Application Gateway. A task that didn’t seem too hard, but was made a bit complicated due to poor documentation… At least the documentation I found… So I thought I would document it in a blog post in case anyone else needed to do the same thing.

Using SSH with multiple identities / certificates

Sat, 05 Dec 2020 13:27:00 +0000

A while back,I decided to start using SSH for all my GIT repos. However, being a consultant, I end up being involved in a lot of different repos, for a lot of different customers. And on top of that, I sometimes write code on my spare time as well. This causes a bit of a problem when it comes to SSH. So I decided to write a a post about how you solve it. It might be obvious to a lot of people, but it might also help someone with the same problem. If nothing else, it will help me when I forget in the future…

Understanding cross platform .NET, and why .NET 5 is important

Wed, 21 Oct 2020 13:27:00 +0000

In the beginning there was .NET Framework, and it was all very simple. But then, over time, it grew and grew, and became a lot more complicated. So, let’s have a look at how it all fits together…ish, and how current and future versions try to make life simpler for us developers.

Getting started with K8s HPA & AKS Cluster Autoscaler

Wed, 14 Oct 2020 14:31:00 +0000

Kubernetes comes with this cool feature called the Horizontal Pod Autoscaler (HPA). It allows you to scale your pods automatically depending on demand. On top of that, the Azure Kubernetes Service (AKS) offers automatic cluster scaling that makes managing the size of your cluster a lot easier.

Getting ASP.NET Core dev certs working in both WSL and Windows

Wed, 30 Sep 2020 12:31:00 +0000

I recently re-installed my development machine for different reasons, and as part of that, I decided that I was going to use Visual Studio Code and the Remote - WSL extension to do my development in Linux for a while.

Spinning up Azure Container Instances using the Docker CLI

Wed, 23 Sep 2020 13:31:00 +0000

The Docker CLI has recently added support for running Docker containers using cloud providers. More specifically using Azure Container Instances and Amazon ECS. This seems like a really cool addition to the CLI, so obviously it has to be tried out and blogged about!

Managing Azure DNS using Kubernetes CRDs

Tue, 30 Jun 2020 15:07:00 +0000

In my last post, I talked about Kubernetes Custom Resource Definitions, or CRDs. It was a fairly high-level intro with some code attached, which I guess could be useful. But to show something that shows that CRDs can be really useful, I decided to build a POC of how to use Kubernetes CRDs together with some .NET Core code and Azure to enable management of Azure DNS records using K8s resources.

Intro to Kubernetes Custom Resource Definitions or CRDs

Thu, 14 May 2020 15:49:00 +0000

After having done a couple of Kubernetes-based projects, I still haven’t had time to dive into Kubernetes Custom Resource Definitions, or CRDs, properly. Because of this, I decided to play around with them a little outside of a real project to see what they are, and how I might be able to use them in future projects.

Assigning Azure managed identities to pods in AKS

Thu, 14 May 2020 15:49:00 +0000

As the title says, this post will cover how you can assign managed identities to your pods when running in Azure Kubernetes Service (AKS). But before we get started, let’s have a quick look at what a managed identity is.

Yet Another Kubernetes Intro - Part 9 - Ingress, Dashboard and extras

Tue, 05 May 2020 16:12:00 +0000

So…it is finally time for the last installment in my introduction to Kubernetes. So far, we have gone through what it is, Pods, ReplicaSets and labels, Services, Deployments, configuration, storagestorage and namespaces and RBACnamespaces and RBAC. That is a lot or information! But wait, there is more!

Yet Another Kubernetes Intro - Part 8 - Namespaces & Access Control

Wed, 22 Apr 2020 12:09:00 +0000

I’m down to what I think is the second to last post in my introduction to Kubernetes series. Up until the last post about storage, I think I had a pretty ok connection between the posts. However, I should maybe have planned the posts a bit better, because this one did unfortunately become a little disjointed as it covers two pretty separate things. I’m sorry about that, but it is pretty useful information.

Yet Another Kubernetes Intro - Part 7 - Storage

Fri, 14 Feb 2020 15:14:00 +0000

It’s time for part 7 in my introduction to Kubernetes. In the previous post, I talked about configuration. This time, it is all about storage!

Yet Another Kubernetes Intro - Part 6 - Configuration

Fri, 14 Feb 2020 15:14:00 +0000

I have reached the 6th part of my introduction to Kubernetes, and so far we have covered a LOT of things. But there is still a few things left to cover.

Yet Another Kubernetes Intro - Part 5 - Deployments

Sun, 02 Feb 2020 17:22:00 +0000

It is time to have a look at the last pod management related resource type in Kubernetes, the Deployment. In part 3 I talked about using ReplicaSets to run multiple pods in our cluster, which is all nice and dandy until you want to update the service you are running. With pure RSs, this can get a bit complicated…

Yet Another Kubernetes Intro - Part 4 - Services

Tue, 21 Jan 2020 17:22:00 +0000

Ok… So far in this series I have covered “What is Kubernetes?”, Pods and ReplicaSets. This means that we should be able to get a basic Kubernetes cluster up and running (at least locally using Docker for Dektop), be able to define our pods, and finally get them up and running in a replicated manner using ReplicaSets. So that is kind of cool. However, we still haven’t covered any form of communication with, or between the pods. Except for doing port forwarding using kubectl port-forward.

Yet Another Kubernetes Intro - Part 3 - ReplicaSets and Labels

Mon, 13 Jan 2020 09:13:00 +0000

In my last post, I covered pods. However, I also mentioned that I was a little bit torn about covering pods, and especially the creation of pods. The main reason for this is that we generally do not create pods on their own. There isn’t really anything wrong with creating pods manually as we did in the previous post. However, in doing so, we are missing out on a bit stuff when it comes to the functionality that Kubernetes offers us.

Yet Another Kubernetes Intro - Part 2 - The Pod

Thu, 05 Dec 2019 11:03:00 +0000

In the previous post, I gave a very high level overview of the Kubernetes landscape. Now it is time to go a little deeper, become a bit more practical, and look at some of the building blocks that we use when we build applications that run in Kubernetes.

Yet Another Kubernetes Intro - Part 1 - What is it?

Fri, 29 Nov 2019 12:00:00 +0000

I’ve spent quite a bit of time trying to learn and understand Kubernetes. And in doing so, I have used numerous different resources on the interwebs to try and make sense of everything. However, no single resource could tell me all the things I wanted/needed to know in a useful way. Instead I ended up Googling quite a bit.

Slow Docker commands on domain joined PC

Tue, 20 Aug 2019 09:30:00 +0000

I recently joined a new company and as part of that I got a new laptop. Normally that just means installing the things I need, and I’m good to go. However, this time I started having issues with Docker for Desktop…

New blog

Tue, 20 Aug 2019 09:30:00 +0000

Ok, I have finally gotten my act together and set up a new blog. The old one was based on BlogEngine.NET, which was really good to be honest. But it was getting old, and I needed to update it, so I decided to go for a new one instead. And after a bit of research I decided to go for a GitHub Pages based blog, using a custom theme.

Versioning ASP.NET Core HTTP APIs using the Accept header

Tue, 25 Jun 2019 10:00:00 +0000

For some reason, I have spent a couple of days thinking about versioning HTTP based APIs. Actually, the reason is that I have a client who is using quite a lot of HTTP based APIs, but in a way that I find less than perfect. I’m not blaming them in any way, as it is the result of growing an application over many years, using many different forms of Microsoft tech, and continuously focusing on delivering features to users instead of building a maintainable system. Currently their application uses ASP.NET WebForms, ASP.NET Core MVC, asmx webservices, WCF webservices, Silverlight, Angular etc, which is what happens in quite a lot of cases over time.

Using Azure Files with Azure Container Services and Docker volumes

Wed, 20 Sep 2017 11:30:00 +0000

As a continuation to my last post about setting up an Azure Container Service, I thought it might be a good idea to have a look at persistent storage for the containers. Even if I prefer “outsourcing” my storage to external services, having persistent storage can be really useful in some cases.

A brief look at Azure Container Service

Wed, 20 Sep 2017 11:30:00 +0000

Yesterday I had a couple of hours left over as I was on a train on the way to do a presentation. So I thought i would play around a little with the Azure Container Service. Seeing that I have gotten hooked on Docker, having the ability to spin up a Docker cluster while on the train using just my mobile phone for the connection, seems like a really cool thing. I guess normal people read books and watch Netflix on the train. Me…I spin up 5 Docker clusters…

My intro to Docker - Part 5 of 5

Mon, 18 Sep 2017 11:30:00 +0000

In the previous posts, I have talked about everything from what Docker is, to how you can set up a stack of containers using docker-compose, but all of the posts have been about setting up containers on a single machine. Something that can be really useful, but imagine being able to deploy your containers just as easily to a cluster of machines. That would be awesome!

My intro to Docker - Part 4 of 5

Wed, 30 Aug 2017 09:30:00 +0000

In the previous posts about Docker, here, here and here, we’ve looked at what Docker is, how to set up a basic container and how to set up a stack of containers using docker-compose. One thing we haven’t talked about is the fact that most projects use some form of persistent data store, and the most common store, at least in my world, is a relational database of some sort. So this time, I want to cover something that might seem slightly odd…setting up an MS SQL Server…on Linux…in Docker.

My intro to Docker - Part 3 of 5

Fri, 25 Aug 2017 09:30:00 +0000

So far in this little blog series about Docker, I have covered what Docker is, how it works, how to get a container up and running using pre-built images, as well as your own images. But so far, it has all been about setting up a single container with some form of application running inside it. What if we have a more complicated scenario? What if we have a couple of different things we want to run together? Maybe we want to run our ASP.NET Core app that we built in the previous post behind an nginx instance instead of exposing the Kestrel server to the internet… Well, obviously Docker has us covered.

My intro to Docker - Part 2 of 5

Thu, 24 Aug 2017 09:30:00 +0000

In the previous post, I talked a bit about what Docker is, how it works, and so on. And I even got to the point of showing how you can create and start containers using existing images from Docker Hub. However, just downloading images and running containers like that, is not very useful. Sure, as a Microsoft dev, it’s kind of cool to start up a Linux container and try out some leet Linux commands in bash. But other than that it is a little limiting. So I thought I would have a look at the next steps involved in making this and actually useful thing…

My intro to Docker - Part 1 of 5

Tue, 22 Aug 2017 09:30:00 +0000

It’s been quite a while since I blogged, and there are several reasons for this. First of all, I haven’t really had the time, but I also haven’t really found a topic that I feel passionate enough about to blog about. But having played around with Docker, I now have! So I thought I would jot down some stuff about Docker… If nothing else, it gives me a away to come back to what I used to know when I have forgotten all of it again…