2025 on Funky Si's Blog (Dev)

A festive naughty or nice checker

funkysi1701@gmail.com (funkysi1701) — Fri, 12 Dec 2025 10:00:00 +0000

Introduction

I’m excited to be taking part in this year’s Festive Tech Calendar , a community-driven advent calendar showcasing amazing technical content throughout December. Make sure to check out the other excellent posts created by developers from around the world!

In this festive tutorial, we’ll build a fun “Naughty or Nice” checker using Microsoft’s Semantic Kernel and .NET. This playful AI-powered tool analyzes text descriptions and delivers a verdict on whether someone has been naughty or nice this year—perfect for adding some holiday cheer to your portfolio! Whether you’re new to AI integration or looking to explore Semantic Kernel, this beginner-friendly guide will walk you through creating a complete working application from scratch. By the end, you’ll have a deployable web app and understand how to integrate large language models into your .NET projects.

My Take on AI

Before diving into code, I want to share a quick perspective on using AI in development. While building this demo, I used GitHub Copilot to transform a basic UI into something more festive.

Starting with a simple, functional interface:

After a few prompts to Copilot, I had a Christmas-themed demo with loading spinners and festive icons:

Could I have coded this myself? Absolutely. But I’d rather focus my energy on the backend Semantic Kernel integration than wrestling with CSS animations. This is where AI shines—handling the tedious parts so you can focus on the interesting problems.

The Reality Check

That said, AI isn’t magic:

Hallucinations happen - I’ve lost time chasing incorrect suggestions, so don’t retire your search engine just yet
Ownership questions remain - Who owns AI-generated code? This is still being figured out
It’s a tool, not a replacement - AI augments developers; it doesn’t replace critical thinking

My approach: Use AI as a productivity multiplier, but always verify, understand, and own what you ship.

What is Semantic Kernel?

Semantic Kernel is an open-source SDK from Microsoft that makes it easy to integrate AI models into your .NET applications. It allows you to use large language models (LLMs) for tasks like text analysis, summarization, and more.

Project Overview

We’ll create a simple web app that:

Accepts a name or short description of someone’s behaviour
Uses Semantic Kernel to analyze the input
Returns a festive verdict: Naughty or Nice

Prerequisites

.NET 10 (I am not using any .NET 10 specific features so could probably be rewritten with older versions)
Semantic Kernel (NuGet package)
An OpenAI API key - ⚠️ Note: API usage costs ~$0.01-0.05 per request

OpenAI and Costs

For this example I have used an OpenAI API Key. This is not free, however while writing this example I have only spent a few pounds in tokens. For more information about OpenAI head over to https://platform.openai.com/

For this reason I have not provided a live demo, (I don’t want you all using my API key), and no API keys are included in my example code.

Step 1: Setting Up the Project

Create a new Blazor Web App:

dotnet new blazor -n NaughtyOrNiceChecker
cd NaughtyOrNiceChecker

Install the required NuGet packages: (Microsoft.SemanticKernel.Connectors.OpenAI Version 1.67.1 as I write this)

dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI

Add your OpenAI configuration to appsettings.json:

{
 "OpenAI": {
 "Key": "your-api-key-here", // Head over to https://platform.openai.com/settings/organization/api-keys
 "Model": "gpt-5" // I am using gpt-5 but feel free to experiment with other models
 }
}

🔒 Security: Never commit API keys to GitHub. Use user secrets or environment variables.

The code for my project can be found on GitHub at https://github.com/funkysi1701/FestiveTechCalendar2025 .

Step 2: Integrate Semantic Kernel

Configure Semantic Kernel to use your LLM provider (OpenAI). In the Program.cs file you will see the following code, this loads the OpenAI key and model from your appsettings.json config file, and allows it to be used by Semantic Kernel.

var key = builder.Configuration.GetValue<string>("OpenAI:Key");
var model = builder.Configuration.GetValue<string>("OpenAI:Model");
if (!string.IsNullOrEmpty(key))
{
 builder.Services.AddOpenAIChatCompletion(
 modelId: model ?? throw new ApplicationException("Missing OpenAI Config"),
 apiKey: key
 );
}
builder.Services.AddKernel();

Step 3: Create the Blazor Component

Create a new file Components/Pages/NaughtyOrNice.razor:

@page "/naughty-or-nice"
@inject Kernel _kernel
@rendermode InteractiveServer

<PageTitle>Naughty or Nice Checker</PageTitle>

<h3>🎅 Naughty or Nice Checker</h3>

<div class="card">
 <div class="card-body">
 <input @bind="input"
 placeholder="Describe their behavior..."
 class="form-control mb-3" />
 <button @onclick="CheckStatus"
 class="btn btn-primary">
 Check Status
 </button>

 @if (!string.IsNullOrEmpty(response))
 {
 <div class="alert alert-@alertClass mt-3">
 <h4>@response</h4>
 </div>
 }
 </div>
</div>

@code {
 private string childsName = "";
 private string response = "";
 private string alertClass => response == "Naughty" ? "danger" : "success";
 private bool isLoading = false;

 public async Task CheckStatus()
 {
 isLoading = true;
 await InvokeAsync(StateHasChanged);
 response = string.Empty;
 try
 {
 var input = (childsName).Trim();
 if (string.IsNullOrEmpty(input))
 {
 return;
 }

 using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
 var prompt = "You are Santa's assistant. Given the child's name or short description, " +
 "decide if they are Naughty or Nice for Christmas. " +
 "Respond only with one word: Naughty or Nice. " +
 "No punctuation, no explanation. Input: {{$input}}";
 var classifyFunc = _kernel.CreateFunctionFromPrompt(prompt);
 var aiResponse = await _kernel.InvokeAsync(
 classifyFunc,
 new()
 {
 ["input"] = input
 },
 cts.Token
 );
 var text = aiResponse.GetValue<string>()?.Trim();

 // Normalize and enforce strict output
 if (string.Equals(text, "naughty", StringComparison.OrdinalIgnoreCase))
 {
 response = "Naughty";
 }
 else if (string.Equals(text, "nice", StringComparison.OrdinalIgnoreCase))
 {
 response = "Nice";
 }
 else
 {
 // Fallback: default to Naughty to avoid leaking other content
 response = "Naughty";
 }
 }
 finally
 {
 isLoading = false;
 await InvokeAsync(StateHasChanged);
 }
 }
}

Note: The _kernel is injected automatically because we registered it in Program.cs with builder.Services.AddKernel().

Step 4: Crafting the Perfect Prompt

Getting AI to return exactly what you want requires iteration. I’ll walk you through my prompt engineering journey from verbose outputs to production-ready responses.

Iteration 1: Too Verbose

var aiResponse = await _kernel.InvokePromptAsync(
 $"You are a tool to help Santa identify if children have been naughty or nice. " +
 $"Has {input} been naughty or nice this year?",
 cancellationToken: cancellationToken.Token
);

Input	Output
Santa	Short answer: Nice. Why: - Spreads joy and generosity globally - Works hard with his team, treats elves and reindeer well - Answers letters and keeps promises (on-time deliveries) Minor demerits (lighthearted): - Excess cookie consumption - Occasional chimney soot prints Verdict: Firmly on the Nice List. Want a fun “Official Nice Report” for Santa you can share?
Darth Vader	Not exactly a child, but Santa checks everyone. Darth Vader’s record this year includes Force-choking subordinates and aiding Imperial oppression—firmly Naughty. Mitigating note: he did protect his son and turn against the Emperor, which earns a small mercy. Final verdict: Naughty list (with a tiny redemption candy cane).
James	I don’t have access to Santa’s list or personal data, so I can’t say for sure about James. But I can help you decide with a quick Naughty/Nice check: Score each item: - Kind and helpful to family/classmates most of the time? (Yes +2, Sometimes +1, No 0) - Tells the truth and takes responsibility? (Yes +2, Sometimes +1, No 0) - Apologizes and makes things right after mistakes? (Yes +2, Sometimes +1, No 0) - Respects rules and others (no bullying or deliberate harm)? (Yes +2, Sometimes +1, No 0; deduct 2 if there’s repeated serious harm) - Does generous things (sharing, chores, helping the community)? (Yes +2, Sometimes +1, No 0) Totals: - 8–10: Nice List - 5–7: Mostly Nice (keep it up) - 2–4: Mixed (needs a December boost) - 0–1 or repeated serious harm: Naughty-for-now (with room to improve) If James needs a boost: make amends where needed, do one unprompted kindness or chore daily, be honest about mistakes right away, and share/donate something or help someone weekly. Share a few examples of James’s year and I’ll help you make the call.
Skeletor	Verdict: Naughty. Why: - Repeated attempts to conquer Eternia and seize Castle Grayskull - Habitual scheming, lying, and bullying his own minions - Frequent unleashing of dangerous magic on innocents Path back to the Nice List: - Call a truce with He-Man and protect Eternia for a season - Return stolen artifacts and undo harmful spells - Treat his minions fairly and do a few good deeds without expecting power in return

This is far too wordy, I really just want a Naughty or Nice response.

Iteration 2: Constraining the Output

Then I tried:

var aiResponse = await _kernel.InvokePromptAsync(
 $"Given the following description, decide if the person is Naughty or Nice for Christmas. " +
 $"Respond only with 'Naughty' or 'Nice'. " +
 $"Description: {input}",
 cancellationToken: cancellationToken.Token
);

Input	Output
Santa	Nice
Darth Vader	Naughty
James	Nice
Skeletor	Naughty

This is better but every name I tried is giving me a Nice, so let’s see if we can try something a bit more clever. However if instead of only including a name, we include some naughty or nice actions we get some interesting results.

Input	Output
Santa delivered some presents	Nice
Darth Vader destroyed Alderaan	Naughty
James tidied his room	Nice
Skeletor got cross with Evil Lynn	Naughty

Version 3: Non-AI Approach (Plugin Example)

This version demonstrates Semantic Kernel’s plugin system without using AI. While it doesn’t actually help Santa (it just generates a hash-based result), it shows how you can integrate traditional .NET code into Semantic Kernel workflows.

Why show this? To illustrate that Semantic Kernel isn’t just for AI—you can mix AI calls with regular code execution in the same pipeline.

var aiResponse = await _kernel.InvokeAsync(
 pluginName,
 "GenerateHash",
 new KernelArguments
 {
 ["input"] = input
 }
);

This version invokes a semantic kernel plugin function called GenerateHash. The function itself is defined in a separate class with a KernelFunction attribute, it is really simple just generates a hash from the input string. This is just an example of how you can call .NET code from Semantic Kernel. The kernel function requires an extra line to wire up correctly I have placed this in the OnInitialized method.

protected override void OnInitialized()
{
 var rngPlugin = new ExamplePlugin();
 _kernel.ImportPluginFromObject(rngPlugin, pluginName);
}

public class ExamplePlugin
{
 [KernelFunction]
 public int GenerateHash(string input)
 {
 if (input == null)
 {
 throw new ArgumentNullException(nameof(input));
 }
 var hash = input.GetHashCode();

 return hash > 0 ? 0 : 1;
 }
}

Final Version: Production-Ready Implementation

My last example is very similar to Version 2 but let’s have a look at it.

var prompt = "You are Santa's assistant. Given the child's name or short description, " +
 "decide if they are Naughty or Nice for Christmas. Respond only with one word: Naughty or Nice. " +
 "No punctuation, no explanation. Input: {{$input}}";
 var classifyFunc = _kernel.CreateFunctionFromPrompt(prompt);
 var aiResponse = await _kernel.InvokeAsync(
 classifyFunc,
 new()
 {
 ["input"] = input
 },
 cancellationToken.Token
 );

Here we have a bit more error checking to make sure we have entered a valid string before calling OpenAI. This time we use the CreateFunctionFromPrompt method to pass in a prompt, we then invoke the prompt along with the string that has been entered.

This time we check for naughty or nice in the response before returning that to the user, if neither is returned we return Naughty.

This works quite well if we enter a more descriptive input.

Input	Output
Santa delivered some presents	Nice
Darth Vader destroyed Alderaan	Naughty
James tidied his room	Nice
Skeletor got cross with Evil Lynn	Naughty

As you can see if we describe the actions of someone we can categorize them as naughty or nice, which is basically what Santa does, so this tool should be a great help to him.

Comparing All Versions

Version	Approach	Pros	Cons	Use Case
1	Open-ended prompt	Rich explanations	Too verbose	Learning/debugging
2	Constrained output	Concise	Needs context	Simple classifications
3	Hash-based (no AI)	No API costs	Not intelligent	Plugin example only
4	Validated prompts	Reliable, safe	More code	Production

Conclusion

In this tutorial, we built a festive AI-powered application using Semantic Kernel and .NET. Here’s what we accomplished:

✅ Integrated OpenAI with Semantic Kernel in a Blazor app
✅ Learned prompt engineering through iteration (4 versions!)
✅ Implemented proper error handling and output validation
✅ Created a fun, interactive holiday application

I have tried to highlight some of the different ways that you can use Semantic Kernel that you could use in your own projects. Some of my examples could be accomplished without the use of Semantic Kernel, for example randomly generating Naughty and Nice doesn’t need AI, however hopefully you can see that getting results from AI can then be augmented using traditional .NET code to execute other functions.

Key Takeaways

Prompt engineering matters - Notice how Version 4’s explicit instructions produced better results
Validation is essential - Always sanitize LLM outputs before displaying to users
Keep it simple - Complex doesn’t mean better (Version 3’s random approach was overkill)

Cost Considerations

During development, I spent only a few pounds on API tokens. For production:

Use Azure OpenAI for predictable pricing
Implement caching for common queries
Set up rate limiting to prevent abuse

Deployment Options

This Blazor app can be deployed to:

Azure Static Web Apps (free tier includes 2 custom domains)
Azure App Service (full .NET hosting)
Docker containers (run anywhere)

Next Steps

Want to extend this project? Try:

Add a database to track naughty/nice history
Implement user authentication
Deploy to Azure Static Web Apps
Add more context (age, location) for better AI decisions

Happy coding and Merry Christmas! 🎄

References:

Blazor and .NET 10 breaking changes

funkysi1701@gmail.com (funkysi1701) — Mon, 17 Nov 2025 20:00:00 +0000

What’s New in .NET 10?

.NET 10 was released this week and it is full of awesome new features. Check it out at .NET Download , there is also a new version of Visual Studio which you should also check out.

I quickly upgraded my .NET projects to take advantage of the new version, but my Blazor WebAssembly (Wasm) project encountered the following error in the browser console:

System.NotSupportedException: net_http_synchronous_reads_not_supported
 at System.Net.Http.BrowserHttpReadStream.Read(Byte[] buffer, Int32 offset, Int32 count)
 at System.IO.DelegatingStream.Read(Byte[] buffer, Int32 offset, Int32 count)
 at System.IO.StreamReader.ReadBuffer(Span`1 userBuffer, Boolean& readToUserBuffer)
 at System.IO.StreamReader.ReadSpan(Span`1 buffer)
 at System.IO.StreamReader.Read(Char[] buffer, Int32 index, Int32 count)
 at Newtonsoft.Json.JsonTextReader.ReadData(Boolean append, Int32 charsRequired)
 at Newtonsoft.Json.JsonTextReader.ReadData(Boolean append)
 at Newtonsoft.Json.JsonTextReader.ParseValue()
 at Newtonsoft.Json.JsonTextReader.Read()
 at Newtonsoft.Json.JsonReader.ReadAndMoveToContent()
 at Newtonsoft.Json.JsonReader.ReadForType(JsonContract contract, Boolean hasConverter)
 at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.Deserialize(JsonReader reader, Type objectType, Boolean checkAdditionalContent)
 at Newtonsoft.Json.JsonSerializer.DeserializeInternal(JsonReader reader, Type objectType)
 at Newtonsoft.Json.JsonSerializer.Deserialize(JsonReader reader, Type objectType)
 at Newtonsoft.Json.JsonSerializer.Deserialize[MyResult](JsonReader reader)
 at MyAPI.Client.MyClient.<ReadObjectResponseAsync>d__57`1[[MyAPI.Client.MyResult, MyAPI.Client, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]].MoveNext()
 at MyAPI.Client.MyClient.MyAsync(MyRequest body, CancellationToken cancellationToken)

This error was getting thrown on a Blazor Wasm page when it tried to make a call to my API. This worked fine in .NET 9 so my suspicion was this might be a breaking change.

The list of new features for .NET 10 can be found .NET 10 Release Notes

HttpClient Response Streaming: Breaking Change in Blazor

I found the following new feature which I suspect is related to my issue:

HttpClient response streaming enabled by default

In prior Blazor releases, response streaming for HttpClient requests was opt-in. Now, response streaming is enabled by default.

This is a breaking change because calling HttpContent.ReadAsStreamAsync for an HttpResponseMessage.Content (response.Content.ReadAsStreamAsync()) returns a BrowserHttpReadStream and no longer a MemoryStream. BrowserHttpReadStream doesn’t support synchronous operations, such as Stream.Read(Span<Byte>). If your code uses synchronous operations, you can opt-out of response streaming or copy the Stream into a MemoryStream yourself.

To opt-out of response streaming globally, use either of the following approaches:

Add the <WasmEnableStreamingResponse> property to the project file with a value of false:

<WasmEnableStreamingResponse>false</WasmEnableStreamingResponse>

Set the DOTNET_WASM_ENABLE_STREAMING_RESPONSE environment variable to false or 0.

To opt-out of response streaming for an individual request, set SetBrowserResponseStreamingEnabled to false on the HttpRequestMessage (requestMessage in the following example):

requestMessage.SetBrowserResponseStreamingEnabled(false);

For more information, see HttpClient and HttpRequestMessage with Fetch API request options (Call web API article).

How to Fix the Streaming Issue in Blazor

To test out if this was the culprit I added <WasmEnableStreamingResponse>false</WasmEnableStreamingResponse> to my csproj file and sure enough this fixed my issue.

Do check out the docs for a complete list of new features and any other potential breaking changes. .NET 10 Release Notes

Periodic Table of DevOps 2025

funkysi1701@gmail.com (funkysi1701) — Mon, 29 Sep 2025 20:00:45 +0000

DevOps has transformed the way teams build, deploy, and manage software. Over the years, the tools we use have evolved rapidly—some have become industry standards, while others have faded away or emerged to solve new challenges. In this post, I revisit the concept of a “Periodic Table of DevOps” to compare the landscape in 2016 with 2025, highlight key changes, and reflect on what these shifts mean for developers, IT professionals, and organizations embracing modern workflows.

The periodic table lists all the chemical elements and groups them together based on some key properties. In 2016 I found an article about the periodic table of DevOps and wrote a blog post about it.

Periodic Table of DevOps Tools 2025

Periodic Table of DevOps Tools 2016

I thought it might be interesting to see what tools are still in use, and what are new.

Source Control

Git, the most popular source control system, is on both charts, in 2016 it was at position 3, and in 2025 it is at 2. GitHub, the most widely used web-based git repository, is also on both charts, moving from 1 to 10. Bitbucket (now owned by Atlassian) was a hosted git repository I used to use and is still on the chart, moving from 11 to 36. Subversion, a source control system I started my career with, has vanished off the chart in 2025. Not really a surprise due to the popularity of git now.

Cloud Platforms

In 2016 we had a whole column of Cloud Platforms, including Rackspace and OpenShift, in 2025 this has been reduced to the big three (Azure, AWS and GCP) plus OpenShift.

Containerization

In 2016 we had a column of tools like Docker, Docker Swarm and Kubernetes. In 2025 there are far more tools in this space, with the addition of tools like Helm and the various ways you can host containers on cloud platforms (like Azure AKS).

Build and Deploy tools

In 2016 Azure DevOps was still called Team Foundation Server, so this has spread out into the various ways you can use Azure DevOps, such as Pipelines and Code. Also since 2016 GitHub Actions has appeared on the market.

In 2016 I was also dabbling with TeamCity, this is no longer used that much so isn’t on the chart in 2025. Jenkins is still around on both charts.

Comms Tools

In 2025 Slack and MS Teams are the go-to tools for communicating with distributed teams, Slack was around in 2016, but Teams wasn’t a thing back then.

New Tools

New tools for monitoring like Grafana have appeared; back in 2016 I was exclusively using Application Insights from Azure.

Conclusion & Key Takeaways

The DevOps landscape has changed dramatically over the past decade. Some tools have stood the test of time, while others have faded or emerged to meet new challenges. Here are the key takeaways:

Git remains the backbone of source control, with platforms like GitHub and Bitbucket continuing to thrive.
Cloud platforms (Azure, AWS, GCP) have become central, reflecting the shift to cloud-native development and operations.
Containerization and orchestration (Docker, Kubernetes, Helm) are now essential, enabling scalable, flexible deployments.
Monitoring and collaboration tools have evolved, with newcomers like Grafana and MS Teams joining established solutions.
Legacy tools are disappearing, showing the importance of adaptability in tech.

As DevOps continues to evolve, staying curious and open to new tools is key. The periodic table analogy reminds us that the right mix of technologies can empower teams to build, deploy, and manage software more effectively. What tools will shape the next decade? Only time will tell.

The Mandelbrot Set

funkysi1701@gmail.com (funkysi1701) — Mon, 15 Sep 2025 20:00:00 +0000

The Mandelbrot Set: Beauty, Chaos, and Mathematical Art

The Mandelbrot set is one of the most iconic images in mathematics—a mesmerizing swirl of fractal patterns, infinite complexity, and unexpected beauty. But what exactly is the Mandelbrot set, and why has it captured the imagination of mathematicians, artists, and curious minds alike?

What Is the Mandelbrot Set?

At its core, the Mandelbrot set is a collection of complex numbers. It’s defined by a simple equation, but the results are anything but simple. The definition is:

A complex number c is in the Mandelbrot set if, when you start with z = 0 and repeatedly apply the function z = z² + c, the value of z remains bounded (does not go to infinity), no matter how many times you iterate.

In other words, for each point c on the complex plane, you check: if you keep plugging it into this formula, does it stay small, or does it spiral out of control? If it stays small forever, it’s in the Mandelbrot set.

From Simple Formula to Stunning Images

The real magic happens when you visualize the Mandelbrot set on a computer. Each point in the complex plane is coloured based on whether it belongs to the set or how quickly it escapes to infinity. The result is a black, bulbous shape surrounded by intricate, infinitely detailed patterns that resemble swirling galaxies, seahorses, or lightning bolts—the Mandelbrot set and its “fractal boundary.”

Zooming in on the edge reveals ever more complexity, with shapes that are reminiscent of the original set at different scales. This property, a form of self-similarity, is a hallmark of fractals.

Why Is the Mandelbrot Set Important?

The Mandelbrot set is more than just a pretty picture. It’s a window into the world of complex dynamics and chaos theory. The set’s boundary is infinitely complex, showing how simple mathematical rules can generate unexpected and beautiful complexity.

It also has deep implications in mathematics:

Fractals: The Mandelbrot set is the most famous example of a fractal—a shape that shows similar, though not identical, patterns at every scale.
Chaos Theory: It illustrates sensitive dependence on initial conditions, where tiny changes can lead to drastically different outcomes.
Complex Numbers: It brings to life the beauty of complex numbers, which are usually abstract concepts in math classes.

The Mandelbrot Set in Art and Culture

Thanks to its stunning visuals, the Mandelbrot set has become a cultural icon. It’s inspired digital art, music, and even jewellery. It also serves as a symbol for how complexity and order can emerge from simple rules, a concept that resonates in fields from biology to computer science.

Try It Yourself

Many websites and software tools let you explore the Mandelbrot set interactively. Try zooming in and discover new shapes and patterns emerging at every level. It’s a fantastic way to experience the intersection of math, art, and chaos.

Final Thoughts

I have been fascinated by fractals since I was young. I remember seeing them generated on a Lynx computer and the process was slow, one pixel at a time, after a few hours you would see a complete Mandelbrot set. More recently I have looked at generating them in the browser (using .NET’s Blazor WebAssembly technology), and the image at the start of this post took only a few seconds to generate.

I’ve also created an interactive Mandelbrot set generator . It’s a work in progress, but you can already generate a set and zoom in using the buttons at the top or by clicking with your mouse. I plan to add more features in the coming weeks.

The Mandelbrot set reminds us that even the simplest equations can produce infinite complexity and beauty. It stands as an enduring inspiration—proof that mathematics is not just about numbers, but about wonder, creativity, and the endless possibilities hidden within the fabric of reality.

The Hacker Ethic

funkysi1701@gmail.com (funkysi1701) — Mon, 01 Sep 2025 20:00:00 +0000

The Hacker Ethic: Principles That Shaped the Digital Age

When most people hear the word “hacker,” they imagine shadowy figures breaking into computer systems. But the original meaning of “hacker” is far richer, rooted in curiosity, creativity, and a set of values that have profoundly shaped technology and culture. This philosophy, known as the hacker ethic, remains a powerful force driving innovation and openness in our digital world.

What Is the Hacker Ethic?

The term “hacker ethic” was popularized by Steven Levy in his book Hackers: Heroes of the Computer Revolution (I have just finished listening to the audio version and highly recommend it). The book describes a set of beliefs and practices developed by early computer enthusiasts at places like MIT, Stanford, and the Homebrew Computer Club. Far from criminality, the hacker ethic is about playful exploration, sharing knowledge, and questioning limits.

The Core Principles

The hacker ethic can be distilled into several key tenets:

1. Access to Computers Should Be Unlimited and Total

Hackers believe that information and tools for learning should be open to all. They value environments where curiosity is encouraged and barriers to entry are low. This spirit led to the creation of open-source software, free educational resources, and collaborative online communities.

2. All Information Wants to Be Free

While not advocating for stealing proprietary data, hackers champion the free flow of information. They believe that sharing code, knowledge, and discoveries accelerates progress and empowers individuals. This principle underlies movements like open data, Creative Commons, and Wikipedia.

3. Mistrust Authority—Promote Decentralization

Hackers are skeptical of gatekeepers and centralized control. They prefer systems that empower individuals and distribute power. This mindset has influenced everything from peer-to-peer networks to blockchain technology.

4. Hackers Should Be Judged by Their Hacking, Not Bogus Criteria

Hackers value skill, creativity, and contribution over credentials or status. In hacker culture, what matters is what you build, solve, or improve—not your job title, age, or background. This meritocratic ideal helped shape the egalitarian ethos of the internet.

5. You Can Create Art and Beauty on a Computer

Hackers see computers not only as tools, but as canvases for creativity. From elegant code to digital art, they celebrate the artistry inherent in technology and design.

6. Computers Can Change Your Life for the Better

Hackers believe in the transformative potential of technology. They see computers as instruments of empowerment, education, and community—tools that can solve meaningful problems and improve lives.

Why the Hacker Ethic Matters Today

The hacker ethic is alive in open-source communities, maker spaces, and digital activism. It challenges us to question closed systems, embrace sharing, and use technology for good. In a world increasingly shaped by algorithms and artificial intelligence, the hacker ethic reminds us that human creativity, curiosity, and collaboration are still at the heart of progress.

After listening to the book, it’s clear that many of today’s security problems stem from this ethic. Early computers and software were built by design without security in mind. The hackers featured in the book strongly disliked passwords and locks; they believed information and systems should be open to all. I had incorrectly assumed this was merely an oversight, or that security wasn’t considered necessary at the time.

The growth of open source software can clearly be seen as an extension to the sharing of code started by these early hackers, instead of looking in a drawer for paper tape containing the code you want to improve, we go to GitHub, but the principle is the same.

Final Thoughts

The hacker ethic is far more than a technical mindset—it’s a philosophy of openness, empowerment, and playful problem-solving. By understanding and embracing these principles, we can build a digital future that is more inclusive, innovative, and free.

The more I think about my career with computers, the more I identify as a hacker rather than a programmer or any other job title. I started hacking together simple web pages, I then hacked away at networks and Active Directory, now I hack at .NET and Kubernetes.

Sponsored Link: Hackers: Heroes of the Computer Revolution (book)

Kubernetes SSL with Let's Encrypt

funkysi1701@gmail.com (funkysi1701) — Mon, 07 Jul 2025 20:00:00 +0000

I have blogged before about how cool Let’s Encrypt is for getting your web things running under https. However I have just got myself a local kubernetes cluster and it is super easy to spin up new web services with SSL certs.

The basic instructions can be found here but let’s look at what was involved.

First of all lets get Cert Manager installed on kubernetes.

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.18.1/cert-manager.yaml

Once the cert manager pods are up, you need to create an issuer which communicates with the lets encrypt API. The first code snippet uses the lets encrypt staging environment to avoid any API limits, the second uses production and uses the cloudflare API to authorize SSL requests.

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
 name: letsencrypt-staging
spec:
 acme:
 server: https://acme-staging-v02.api.letsencrypt.org/directory
 email: your-email@example.com
 privateKeySecretRef:
 name: letsencrypt-staging
 solvers:
 - http01:
 ingress:
 ingressClassName: nginx

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
 name: letsencrypt-prod
spec:
 acme:
 server: https://acme-v02.api.letsencrypt.org/directory
 email: your-email@example.com
 privateKeySecretRef:
 name: letsencrypt-prod
 solvers:
 - dns01:
 cloudflare:
 apiTokenSecretRef:
 key: api-key
 name: cloudflare-api-token-secret
 email: your-email@example.com

Now that is all configured all I need to do is update my helm chart and any pod I like can have a sub domain of funkysi1701.com with a lets encrypt SSL cert.

This is a section from my helm chart which defines the domain name to use and what issuer to use for the certificate.

ingress:
 enabled: true
 className: "nginx"
 annotations:
 cert-manager.io/cluster-issuer: letsencrypt-prod
 devHost: helloworld-dev.funkysi1701.com
 testHost: helloworld-test.funkysi1701.com
 tls:
 - secretName: helloworld-dev.funkysi1701.com
 hosts:
 - helloworld-dev.funkysi1701.com
 - secretName: helloworld-test.funkysi1701.com
 hosts:
 - helloworld-test.funkysi1701.com

All I need to do now is add similar code like this to every helm chart I publish and my pod will request a SSL certificate. The only manual step I have is to set up a DNS record pointing to the IP address of my cluster for any domain I want to use.

Conclusion

Setting up Let’s Encrypt with Kubernetes and Cert Manager has made it incredibly easy to secure my web services with SSL certificates. With just a few YAML configurations and some simple Helm chart updates, I can automatically provision and renew certificates for any subdomain I need. This approach not only saves time but also ensures my services are always protected with up-to-date encryption. If you’re running Kubernetes, I highly recommend giving Cert Manager and Let’s Encrypt a try for hassle-free SSL management.

Stepping outside my comfort zone

funkysi1701@gmail.com (funkysi1701) — Mon, 02 Jun 2025 20:00:00 +0000

Stepping outside my comfort zone doesn’t come naturally to me. I’m happiest behind my laptop, but every now and then, I know it’s important to try something new. This year, my family and I decided to do just that—and it turned out to be one of our most memorable weeks ever. Curious about what happens when you swap routine for adventure? Read on!

Introduction

This week was our family holiday. Normally, we’d book a cottage somewhere nice and explore at our own pace. But this often leads to disagreements—everyone wants something different, and sometimes the places we visit aren’t as exciting as we hoped (especially for two kids aged 7 and 9 who get bored easily).

This time, we chose a different path: a family adventure holiday with High Adventure . The itinerary was packed: climbing, caving, hiking, water sports, archery, zip wires, and countless other activities. All meals, accommodation, equipment, and expert instructors were included, making it feel both safe and exciting.

I’ll admit, I was anxious before we set off. I’m not an adventurous person—I like walking , but I’d never tried anything like this. My nine-year-old son was dreading it, while my more adventurous seven-year-old was quietly excited. I worried that if the kids hated it, it would be a waste of money. But as soon as we arrived, those fears melted away.

Saturday

We arrived on Saturday afternoon and were shown to our room. My only real complaint from the whole week: the room was tiny. With two bunk beds and four of us plus a week’s worth of clothes, it was a challenge to keep things tidy. Thankfully, the rest of the facility was spacious, and our room was right next to the games room—a bonus.

Dinner was served at 6pm every evening, always a home-cooked meal. While I enjoyed the food, my fussy eaters weren’t always convinced, but there was usually something for everyone. We met the other family we’d be doing activities with.

After dinner, we explored the Games Room and took on the Labyrinth—a tight, dark maze constructed under the floor. Helmets were required! I found it a bit tight, but my boys absolutely loved it.

Sunday

Every day began with a cooked breakfast and a make-your-own sandwich station for lunch. Sunday morning kicked off with climbing and abseiling. I’d never climbed before, so I was surprised—and proud—to make it all the way to the top of the 8-meter wall. My boys didn’t quite reach the top, but they pushed themselves higher than I expected. Abseiling was fun too, and a great way to come down after the climb.

After lunch, we tried archery. I’d done it once before at my boys’ Scout group, but it took a while to hit the target consistently. Then came bushcraft: foraging for wood, using a knife to make kindling, and lighting a fire with a ferrocerium rod. My nine-year-old and I managed to get a fire going—definitely a memorable moment, especially when we roasted marshmallows.

The evening’s activity was Nightline: a blindfolded obstacle course. This was a bit much for me, but the boys loved it. My job was to guide them through the course, describing what to climb over, under, or through, and when to stop.

Monday

Monday started with a walk up the hill to Wainman’s Pinnacle and some “weaseling” through the rocks—a favourite for the boys, especially since they’d done it before with Scouts. I skipped most of the weaseling but enjoyed the walk.

In the afternoon, it was time for high ropes and a zip wire. We were safely roped in at all times, but stepping off a high ledge still required a leap of faith. My eldest was nervous and had to climb down at first, but after watching me try, he gave it another go—and loved it. That’s what this week was about: encouraging all of us to try new things.

The evening activity was Eggbert: designing a contraption to protect an egg dropped from a height. We worked as a family, but failed to consider that the weight would flip the egg so it landed the wrong way up. Oops! We didn’t win, but it was great fun seeing everyone’s creative designs.

Tuesday

Tuesday was our first full day offsite. The instructors drove us in a minibus to the Yorkshire Three Peaks area, where we explored underground caves. Wearing cave suits, wellies, and helmets, we were ready for adventure. I foolishly thought I wouldn’t need a change of clothes—turns out, crawling through water-filled tunnels means your wellies fill up fast! I wasn’t the biggest fan of being soaked, but the boys loved climbing and sliding through the narrow passages. We finished the day with ice cream and hot chocolate in Settle—a well-deserved treat.

That evening, we tried circus skills and gathered around a campfire. The boys were entertained for ages, trying juggling and balance activities. I didn’t master anything, but I enjoyed relaxing by the fire with my wife and the other parents.

Wednesday

By Wednesday, tiredness was catching up with me! We tackled a five-mile walk around Malham Cove, taking in stunning views and great weather. The route included Gordale Scar and Janet’s Foss, a lovely waterfall where many people swam or paddled. We hadn’t brought towels, but that didn’t stop my boys from getting soaked. It’s a holiday—why not?

Wednesday evening was supposed to be a parents’ night off, but we had to cut it short due to a family emergency.

Thursday

Thursday was water sports day, but we decided on a quieter option and visited Haworth instead. The town is famous for the Brontë sisters, and we enjoyed its picturesque streets, a museum, and a play area for the kids—a great way to wind down after so much activity.

The final evening was a quiz night, complete with questions about the week’s adventures.

Friday

Friday was going-home day, but not before one last challenge: orienteering. As a former university orienteering club member, I couldn’t resist joining in!

Conclusion

This week was truly about stepping outside my comfort zone and embracing new experiences. From climbing and caving to bushcraft and zip lines, every activity challenged me and helped me grow. I discovered that pushing your boundaries can be both exciting and rewarding—and creates memories that last a lifetime. If you ever get the chance to try something new, even if it feels a bit daunting, I highly recommend taking the leap. You might just surprise yourself!

Deploy this blog with Helm charts

funkysi1701@gmail.com (funkysi1701) — Mon, 26 May 2025 20:00:00 +0000

Helm allows you to package your Kubernetes resources, manage configuration, and deploy updates with a single command.

In this post, I’ll share how I used Helm to deploy my Hugo blog, making it easy to manage updates and spin up new environments. Full disclosure: My blog currently runs on an Azure Static Web App, but now that I know how to deploy to a Kubernetes cluster, I have the option to switch if needed.

Why Use Helm?

Helm is the package manager for Kubernetes. It lets you:

Template your Kubernetes YAML files for reuse and configuration.
Version your deployments for easy rollbacks.
Share your charts with others or use community charts.

Creating a Helm Chart for Hugo

First, I scaffolded a new Helm chart:

helm create hugo-blog

This creates a directory structure with templates for deployments, services, and ingress.

Customizing the Chart

I edited values.yaml to set my image and service details:

image:
 repository: mydockerhubusername/hugo-blog # Docker image repository
 tag: latest # Use the latest tag for the image
 pullPolicy: IfNotPresent # Pull the image only if it’s not already present

service:
 type: NodePort # Expose the service on a specific port
 port: 80 # Internal port for the service
 nodePort: 30081 # External port for accessing the service

Deploying the Blog

To deploy the blog, I ran:

helm install my-hugo-blog ./hugo-blog

Helm rendered the templates and created the necessary Kubernetes resources.

Updating the Blog

When I rebuild and push a new Docker image, I can upgrade my deployment with:

helm upgrade my-hugo-blog ./hugo-blog

This triggers a rolling update in Kubernetes.

Creating a Docker Image of my Blog

This all assumes that I have a container image of my Hugo blog. Creating this was half the work.

I had been using a docker-compose file to build my blog; however, this doesn’t copy my files into the container it creates a volume to share my files with the container. I needed a Dockerfile that would copy my source code into a container and then save it into a container registry.

This is the Dockerfile I created. As you can see, it is a two-stage build. First, it takes the Hugo base image, copies my files into it, and builds Hugo. Then the NGINX web server is run, and the default web port 80 is exposed.

# Step 1: Build the Hugo site
FROM floryn90/hugo:0.119.0 AS builder

# Set working directory inside the container
WORKDIR /src

# Copy site files to the container
COPY . .

# Build the Hugo site
RUN hugo --minify --config config.toml

# Step 2: Serve with nginx
FROM nginx:alpine

# Remove the default nginx static files
RUN rm -rf /usr/share/nginx/html/*

# Copy the generated site from the builder stage
COPY --from=builder /src/public /usr/share/nginx/html

# Expose port 80
EXPOSE 80

# Start nginx
CMD ["nginx", "-g", "daemon off;"]

Benefits

Repeatable Deployments: Easily spin up new environments.
Configuration Management: Override values for different clusters or environments.
Easy Updates: Upgrade with a single command.

Conclusion

Helm charts have made deploying my Hugo blog to Kubernetes a seamless and efficient process. With features like templating, versioning, and easy updates, Helm is a must-have tool for Kubernetes deployments.

If you’re managing static sites or microservices, give Helm a try and see how it can simplify your workflow!

Have you used Helm for static sites or blogs? Share your experience in the comments below!

Learning Kubernetes: A Beginner's Journey

funkysi1701@gmail.com (funkysi1701) — Mon, 12 May 2025 20:00:00 +0000

I know nothing (or very little) about Kubernetes. It is high time I do something to learn more about it. Kubernetes is a powerful tool for managing containerized applications, and it’s becoming a must-have skill for developers and DevOps engineers. In this blog, I’ll share my journey as a beginner exploring Kubernetes, from running a simple Grafana pod to understanding the basics of kubectl. Let’s dive in!

What is Kubernetes?

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. If you want to run your containerized applications, you probably want to learn Kubernetes.

I have worked at least two companies so far in my career that have made use of Kubernetes to run their microservice architecture. Let’s take a look at how to use it.

Why Learn Kubernetes?

Kubernetes is widely used in modern software development for:

Microservices: Manage and scale multiple services independently.
CI/CD Pipelines: Automate deployments and rollbacks.
Scalability: Handle traffic spikes by scaling pods up or down.

Docker Desktop

Docker Desktop is a tool for running containers, but it also allows running of Kubernetes.

I am not going to talk through installing docker desktop and getting a Kubernetes cluster set up, for that check out the documentation however I found it very straightforward.

kubectl

kubectl is the command line tool for doing everything with Kubernetes.

kubectl version

This prints out basic version information, if this works you know Kubernetes must be working.

kubectl config get-contexts
kubectl config use-context docker-desktop

This command allows you to switch contexts, to use with docker desktop you want to use the docker-desktop context. At work we have dev and test contexts that can be selected in a similar way.

Context: A Kubernetes context is a set of access parameters for a cluster. It allows you to switch between different clusters or environments (e.g., dev, test, production).

kubectl get all

This gives you a list of everything that is running in the default namespace, pods, services, deployments etc For a complete list, you can add the –all-namespaces flag.

Namespace: A namespace is a way to organize resources in a Kubernetes cluster, providing isolation between different projects or teams.

Hello World

Now what is the equivalent of “Hello World” for Kubernetes? I think getting a container to run in Kubernetes is a pretty good test.

Open up VS Code and create a yaml file called grafana.yaml

apiVersion: v1 # Specifies the API version for the resource
kind: Pod # Defines the resource type as a Pod
metadata:
 name: grafana # The name of the pod
spec:
 containers:
 - name: grafana # The name of the container
 image: grafana/grafana:12.0.0 # The container image to use
 ports:
 - containerPort: 3000 # The port exposed by the container

This file uses the Grafana container image, which I am familiar with (see my previous blog posts ) It’s default port is 3000 which you can see is defined in this file.

kubectl apply -f grafana.yaml

This deploys a pod, using the above yaml file.

You can run the following to find out more about the pod.

kubectl describe pod grafana

From what I have discovered so far, Kubernetes runs in its own network. So going to localhost:3000 won’t work. But you can use port forward to get round this issue.

Port-Forwarding: This allows you to access a pod’s service on your local machine by forwarding a port from the pod to your localhost.

kubectl port-forward pod/grafana 3000:3000

Now if I try http://localhost:3000/login I see the login page for the Grafana container. A pretty good first test of using Kubernetes.

Whats next?

I want to replace my local deployment of containers that is currently using a docker compose file with Kubernetes. I also want to learn more about Helm charts as I believe these are an excellent way of packaging up changes to Kubernetes.

Have you tried running a pod in Kubernetes? What challenges did you face, and how did you overcome them? Share your thoughts in the comments below!

Getting started with OpenTelemetry

funkysi1701@gmail.com (funkysi1701) — Mon, 05 May 2025 20:00:00 +0000

What is OpenTelemetry?

OpenTelemetry is an open-source observability framework that provides a unified way to collect, process, and export telemetry data such as traces, metrics, and logs. It is designed to help developers monitor and debug distributed systems by providing insights into application performance and behavior.

With OpenTelemetry, you can instrument your applications to gain visibility into how requests flow through your system, identify bottlenecks, and troubleshoot issues effectively.

Why Use OpenTelemetry?

Here are some key benefits of using OpenTelemetry:

Unified Observability: Collect traces, metrics, and logs using a single framework.
Vendor-Neutral: Export telemetry data to any backend, such as Azure Monitor, Grafana, or Prometheus.
Standardized APIs: Use consistent APIs and SDKs across multiple programming languages.
Extensibility: Easily extend OpenTelemetry to meet your specific observability needs.
Community-Driven: Backed by a large and active open-source community.

Key Components of OpenTelemetry

OpenTelemetry consists of the following core components:

Traces: Capture the lifecycle of a request as it flows through your system. Traces help you understand dependencies and latency.
Metrics: Collect numerical data, such as request counts, CPU usage, and memory consumption, to monitor system health.
Logs: Record discrete events, such as errors or state changes, to provide additional context for debugging.

Setting Up OpenTelemetry in .NET

Here’s how you can get started with OpenTelemetry in a .NET application:

Step 1: Install the Required NuGet Packages

Run the following commands to install the OpenTelemetry libraries:

dotnet add package OpenTelemetry
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Exporter.Console

Step 2: Configure OpenTelemetry in Your Application

Add the following code to your Program.cs or Startup.cs file:

using OpenTelemetry;
using OpenTelemetry.Trace;
using OpenTelemetry.Metrics;

var builder = WebApplication.CreateBuilder(args);

// Add OpenTelemetry tracing and metrics
builder.Services.AddOpenTelemetry()
 .WithTracing(tracerProviderBuilder =>
 {
 tracerProviderBuilder
 .AddAspNetCoreInstrumentation()
 .AddHttpClientInstrumentation()
 .AddConsoleExporter(); // Export traces to the console
 })
 .WithMetrics(metricsProviderBuilder =>
 {
 metricsProviderBuilder
 .AddAspNetCoreInstrumentation()
 .AddRuntimeInstrumentation()
 .AddConsoleExporter(); // Export metrics to the console
 });

var app = builder.Build();

app.MapGet("/", () => "Hello, OpenTelemetry!");

app.Run();

Step 3: Run Your Application

Start your application and observe the telemetry data in the console. You’ll see traces and metrics being logged as requests are processed.

Aspire and how to view Telemetry

If your .NET code is .Net 8 or higher you can use Aspire which configures OpenTelemetry for free! Check out Getting started with .Net Aspire . Once Aspire is setup, you will be able to see Logs, Traces and Metrics in the Aspire Dashboard.

Another popular way to view your data is Grafana, where you can create custom dashboards. I have talked about adding Logs to Grafana recently.

There are lots of other ways to view your data, like Application Insights, DataDog, Jaeger, New Relic and many more.

But you are not tied to one solution, you can send your data to more than one of these if you wish.

Conclusion

OpenTelemetry simplifies observability by providing a unified framework for collecting traces, metrics, and logs. Whether you’re building microservices, monitoring distributed systems, or debugging performance issues, OpenTelemetry is a powerful tool to have in your arsenal.

Start using OpenTelemetry today and gain deeper insights into your applications!

Have you tried OpenTelemetry? Share your experiences and tips in the comments below!

New in .NET Aspire 9.2: diagrams

funkysi1701@gmail.com (funkysi1701) — Mon, 21 Apr 2025 20:00:00 +0000

.NET Aspire 9.2 is here, bringing exciting new features to simplify infrastructure visualization. Whether you’re managing microservices or exploring Docker-based architectures, this release makes it easier than ever to create detailed infrastructure diagrams with minimal effort. Let’s dive into the highlights and see how you can use these tools to streamline your workflow.

For details of what .NET Aspire is, check out my post from last year. For the official announcement see What’s new in .NET Aspire 9.2

My favourite feature from this release is the ability to quickly and easily spin up infrastructure diagrams like this:

An example infrastructure diagram created using .NET Aspire 9.2.

I also created one last week for my blog about Grafana :

So what code is needed to create one of these diagrams?

Open Visual Studio and create a new project of type “.NET Aspire App Host”
Edit the Program.cs and add docker containers for anything you want to display on the diagram
The syntax for this is is shown in my Grafana example:

var builder = DistributedApplication.CreateBuilder(args);

// Add a .NET application container
var dotnet = builder.AddContainer("dotnet-application", "anyimage")
 .WithHttpEndpoint(port: 80, targetPort: 80); // Expose HTTP port 80

// Add a Loki container for log aggregation
var loki = builder.AddContainer("loki", "grafana/loki", "3.4.3")
 .WithHttpEndpoint(port: 3100, targetPort: 3100); // Expose HTTP port 3100

// Add an Alloy container for telemetry processing
var alloy = builder.AddContainer("alloy", "grafana/alloy", "v1.8.1")
 .WithHttpEndpoint(port: 12345, targetPort: 12345, name: "UI") // Expose UI
 .WithHttpEndpoint(port: 4317, targetPort: 4317, name: "gRPC") // Expose gRPC
 .WithHttpEndpoint(port: 4318, targetPort: 4318, "http"); // Expose HTTP

// Add a Grafana container for visualization
var grafana = builder.AddContainer("grafana", "grafana/grafana", "11.6.0")
 .WithHttpEndpoint(port: 3000, targetPort: 3000); // Expose HTTP port 3000

// Define relationships between containers
dotnet.WithReferenceRelationship(alloy); // Logs flow from .NET app to Alloy

alloy.WithReferenceRelationship(loki); // Logs flow from Alloy to Loki

loki.WithReferenceRelationship(grafana); // Logs flow from Loki to Grafana

builder.Build().Run();

The parameters for AddContainer() are a name that gets displayed on the diagram, the docker image name, and the tag. The tag is optional and it will use latest if omitted. For my Grafana example, the first docker container I added is for any dotnet application. I can use any docker image for this, as all I want is a container labelled “dotnet-application”. The .WithHttpEndpoint is for public ports to be displayed so you can see how communication is flowing between containers.

.WithReferenceRelationship() is how you define what calls what. So dotnet.WithReferenceRelationship(alloy) adds an arrow pointing from my dotnet application to alloy, suggesting that open telemetry logs flow from my application to alloy. You can also add calls in both directions by adding alloy.WithReferenceRelationship(dotnet) this will change the arrow to point in both directions.

At my work we use a microservice architecture so I thought it might be fun to try and map out what calls what:

A simplified view of a microservices architecture at work (service names anonymized).

I made a start mapping a few of our services, but this doesn’t cover everything and I have replaced the names of the services so no commerical secrets can be identified. I was surprised at how complex the system is.

Real-World Applications

The ability to generate infrastructure diagrams is invaluable for:

Microservices Architecture: Visualize how services interact and identify bottlenecks.
Debugging: Quickly understand communication flows to troubleshoot issues.
Documentation: Create up-to-date diagrams for team collaboration and onboarding.

Conclusion

.NET Aspire 9.2 makes it easier than ever to create detailed infrastructure diagrams, saving time and improving collaboration. Whether you’re managing microservices or exploring Docker-based architectures, these tools can help you visualize and optimize your systems. Give it a try and see how it can enhance your workflow!

Have you tried .NET Aspire 9.2? What features are you most excited about? Share your thoughts and experiences in the comments below!

OpenTelemetry logs via Grafana Loki

funkysi1701@gmail.com (funkysi1701) — Mon, 14 Apr 2025 20:00:00 +0000

Logs are a critical part of monitoring and debugging modern applications. By integrating OpenTelemetry logs with Grafana using Loki and Alloy, you can centralize your log data, making it easier to analyze and monitor your .NET applications. In this blog, I’ll walk you through the setup process and share how these tools work together to streamline log aggregation and visualization.

I have blogged about Grafana before but until now I haven’t added logs to Grafana let’s have a look at how that works.

My dotnet application makes use of OpenTelemetry. I have been sending this telemetry to an Aspire Dashboard running in Docker. This allows me to view logs, metrics and traces.

Grafana has several tools that can help with logs.

Loki: A log aggregation system designed to store and query logs from applications and infrastructure.
Alloy: An OpenTelemetry collector that processes and forwards telemetry data.
OpenTelemetry: A set of APIs, libraries, and tools for collecting and exporting telemetry data like logs, metrics, and traces.

I am using Alloy to collect OpenTelemetry from my application and send it to Loki, The logs in Loki can then be read by Grafana.

Setting Up Loki and Alloy with Docker Compose

To start off let’s add Alloy and Loki to my docker compose file.

Docker Compose Configuration

The docker-compose.yml file defines the services for Loki and Alloy. Here’s what each section does:

Loki: Runs the Loki container on port 3100 and uses a local configuration file.
Alloy: Runs the Alloy container, exposing ports for receiving telemetry data and processing logs.

# Docker Compose configuration for Loki and Alloy
 command: -config.file=/etc/loki/local-config.yaml # Specifies the configuration file for Loki

 alloy:
 image: grafana/alloy:v1.8.1
 container_name: monitoring_alloy
 ports:
 - 12345:12345 # HTTP server for Alloy
 - 4317:4317 # gRPC endpoint for OpenTelemetry
 - 4319:4318 # HTTP endpoint for OpenTelemetry
 volumes:
 - ./config.alloy:/etc/alloy/config.alloy # Mount Alloy configuration
 command: run --server.http.listen-addr=0.0.0.0:12345 --storage.path=/var/lib/alloy/data /etc/alloy/config.alloy
 depends_on:
 - loki

Here is the config file for Alloy.

otelcol.receiver.otlp "default" {
http {}
grpc {}
output {
logs = [otelcol.processor.batch.default.input]
}
}
otelcol.processor.batch "default" {
output {
logs = [
otelcol.exporter.otlphttp.loki.input,
]
}
}
otelcol.exporter.otlphttp "loki" {
client {
endpoint = "http://loki:3100/otlp"
}
}

How the Components Work Together

Application Logs: The .NET application generates logs and sends them to Alloy on port 4317.
Alloy Processing: Alloy processes the logs and forwards them to Loki on port 3100.
Loki Storage: Loki stores the logs, making them available for querying.
Grafana Visualization: Grafana connects to Loki as a data source, allowing you to visualize and analyze the logs.

Handling Aspire Dashboard Logs

By default, sending logs to Alloy and Loki means Aspire Dashboard will no longer receive them. To resolve this, you can configure the AddOpenTelemetryExporters method in your .NET application to send logs to multiple destinations.

if (useOtlpExporter)
{
 // The following lines enable the OTLP exporter (requires the OpenTelemetry.Exporter.OpenTelemetryProtocol package)
 builder.Services.AddOpenTelemetry()
 .WithLogging(logging => logging.AddOtlpExporter(options =>
 {
 options.Endpoint = new Uri(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);
 }))
 .WithLogging(logging => logging.AddOtlpExporter(options =>
 {
 options.Endpoint = new Uri(builder.Configuration["GrafanaExporter"]);
 }))
 .WithMetrics(metrics => metrics.AddOtlpExporter(options =>
 {
 options.Endpoint = new Uri(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);
 }))
 .WithTracing(tracing => tracing.AddOtlpExporter(options =>
 {
 options.Endpoint = new Uri(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);
 }));
}

If I update the AddOpenTelemetryExporters method in my Extensions.cs file in my .Net Aspire ServiceDefaults project, I can get my logs (or traces/metrics) to be sent to as many different places as I want. In my case I am sending to Allot and Aspire Dashboard.

Conclusion

Integrating OpenTelemetry logs with Grafana using Loki and Alloy provides a powerful solution for centralized log aggregation and monitoring. This setup simplifies debugging and enhances visibility into your application’s behaviour. If you haven’t tried it yet, give it a go and let me know your thoughts in the comments!

Exploring ChatGPT image generation

funkysi1701@gmail.com (funkysi1701) — Mon, 07 Apr 2025 20:00:00 +0000

Fun with AI

AI tools like ChatGPT are evolving rapidly, and their creative capabilities are nothing short of amazing. Recently, I decided to test its image generation features with a fun and quirky prompt. The results? A personalized action figure concept that blew my mind! Let me walk you through the process and share the results.

I used the following prompt:

Draw an action figure toy of the person in this photo.
The action figure should be full-figure and displayed in its original blister pack packaging.
On top of the box is the name of the toy "Software Developer" across a single line of text.
In the blister pack packaging, next to the figure, show the toy's accessories,
including a Microsoft laptop,
cup of coffee,
the Visual Studio app,
GitHub app,
and the Azure app.
There should be a label on the corner of the box that says "Limited Edition".
This figure should look like a premium toy and everything should be inside the plastic!

and I supplied the following image:	and this is the result:

Pretty cool, right? Well I can’t take the credit for the prompt, It comes from Amy Ru on LinkedIn.

Have you tried ChatGPT’s image generation features? What creative prompts have you used? Share your experiences in the comments below!

Automate social posts with AI in .NET

funkysi1701@gmail.com (funkysi1701) — Mon, 17 Mar 2025 20:00:00 +0000

Automating repetitive tasks is one of the best ways to save time and focus on what matters most. In this blog, I’ll show you how I used AI with .NET to automate the creation of social media posts for my blog. By leveraging my blog’s RSS feed, OpenAI, and Semantic Kernel, I was able to generate engaging posts effortlessly. Let’s dive in!

Let’s look at a way to use AI for a practical use. For the last few weeks I have been using AI to help me write social media posts to promote my latest blog posts, let’s look at how I might automate this using .NET code.

My blog publishes new posts to a rss feed, I can consume this from .NET code and pass it to AI, and create social media posts from them.

My blog is written in Hugo and it is already generating an rss feed, however I have made a slight tweak to it. I want the tags from the blog article to be used as hashtags in any social media posts. I am storing the tags in the rss field category.

<category term="tagname">tagname</category>

And here is the section of code that generates my rss feed, the key tags I will be using are title, link, category and description.

<item>
 <title>{{ .Title }}</title>
 <link>{{ .Permalink }}</link>
 <author>{{ with .Params.author }}{{ . }}{{ else }}{{ with $.Site.Author.name }}{{.}}{{end}}{{end}}</author>
 <pubDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</pubDate>
 {{ with .Site.Author.email }}<author>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</author>{{end}}
 <guid>{{ .Permalink }}</guid>
 {{- range .Params.tags -}}
 <category term="{{ replace . " " "" }}">{{ replace . " " "" }}</category>
 {{ end }}
 <description>{{ .Content | html }}</description>
</item>

I am using the nuget package CodeHollow.FeedReader , this allows me to pass in a URL to my rss feed, and get an object out which contains all the items in the feed. Using a nuget package saves me doing a lot of parsing of XML. The method I am using takes an input string something like https://www.funkysi1701.com/index.xml , and gives me an object I can query and do things with.

var RSSFeed = await FeedReader.ReadAsync(FeedStringValue);

RSS feed contains the following properties I want to use: Title, Link, Categories and Description. All are strings, except Categories which is an ICollection<string> This matches what I said I wanted to use from the rss feed.

I want to pass the description to AI, and then combine the Response from AI with URL of the blog post and a comma separated list of ‘hashtags’ (the categories in my rss feed).

Initially I thought about using ollama , this is an example of a LLM (Large Language Model) that you can install on your laptop, sometimes called a Small Language Model (SLM). However, I found this to be unreliable with my laptop and caused several system wide crashes. I assume this is due to memory usage and the size of the model. LLMs or SLMs do require a lot of system resources so this is not completely surprising. I will revisit this at some point as I would like to learn more about ollama.

I already have an account on OpenAI and some credit so let’s try that instead. I have made a fair few requests using OpenAI and so far it has cost me 11p, I don’t think for my usage it is going to break the bank. If I was going to put something on the public internet I may have to reconsider but for my own personal use I think this should be fine.

Next step, how do I talk to OpenAI from .NET. I know of two approaches, Semantic Kernel and the new Microsoft.Extensions.AI libraries introduces in .NET 9 https://devblogs.microsoft.com/dotnet/introducing-microsoft-extensions-ai-preview/ . Semantic Kernel is what I am using here, however I do want to explore the newer libraries at some point.

Semantic Kernel with OpenAI needs the following Nuget package: Microsoft.SemanticKernel.Connectors.OpenAI

In my Program.cs I had the following to register and add to dependency injection.

if (builder.Configuration.GetValue<string>("OpenAI:Key") != string.Empty)
{
 builder.Services.AddOpenAIChatCompletion(
 modelId: builder.Configuration.GetValue<string>("OpenAI:Model") ?? string.Empty,
 apiKey: builder.Configuration.GetValue<string>("OpenAI:Key") ?? string.Empty
 );
}

builder.Services.AddTransient((serviceProvider) => new Kernel(serviceProvider));

OpenAI:Key is your API Key, which can be found from the OpenAI site, https://platform.openai.com/api-keys OpenAI:Model is the model I am using, in my case “gpt-4o”, I’ve added it as a config option as I may find I want to change it.

Now in the code where I want to call OpenAI I can just inject SemanticKernel and call its async methods. I am a backend developer, so I created a simple API that allows me to call it.

public class AIHandler(Kernel kernel)
{
 public async Task Handle(string request, CancellationToken cancellationToken)
 {
 var response = await kernel.InvokePromptAsync(request, cancellationToken);
 // Do something with the response...
 }
}

Now the only step I am missing is what string or prompt do I want to pass to OpenAI?

I want a social media post that will fit into a facebook/twitter/bluesky etc post, some of these services are character limited so I have included a character limit in my “prompt”, however I am being clever and counting the number of characters taken up by the URL and hashtags and subtracting that first.

string socialMediaPrompt = $"write a social media post under {240 - length} characters, excluding hash tags about {feedItem.Description}"

Now once I put is all together I have a page that loads my rss feed, and I can click a button to generate a social media post.

Conclusion

By combining .NET, Semantic Kernel, and OpenAI, I was able to automate the creation of social media posts, saving time and effort. This approach can be adapted for other use cases, such as summarizing content or generating marketing copy.

If you have enjoyed this article and want to get a monthly email with all my latest articles, please sign up to my newsletter . If you have any questions or want to share your own experiences, feel free to leave a comment below!

Merge two Git projects, keep history

funkysi1701@gmail.com (funkysi1701) — Mon, 10 Mar 2025 20:00:00 +0000

I needed to merge two separate projects into one repository while keeping the full commit history from both sides. Copy-paste would have worked for the files, but history would have stayed trapped in the old remotes.

This approach adds the second repo as a remote, fetches it, and merges with --allow-unrelated-histories so Git keeps both lineages. I still refer to the repos as project1 and project2, with remotes at project1Url and project2Url.

Step 1: Clone the original repository

First, clone the repository of project1:

git clone project1Url

Step 2: Add the new repository as a remote

Next, add the repository of project2 as a remote:

git remote add project2 project2Url

Step 3: Fetch the commits from the new repository

Fetch the commits from the project2 repository:

git fetch project2

Step 4: Merge the commits from the new repository

Merge the commits from the project2 repository into project1. Point at the branch that holds the code you want (often main or develop):

git merge project2/develop --allow-unrelated-histories

Step 5: Fix merge conflicts

If there are conflicts, you will need to resolve them. In my case, this was mainly build files and scripts in the root of the repository. Most of the important code was in subfolders, so this was minimal.

Step 6: Push the changes to the original repository

Push the changes to a new branch for review before merging into the main branch:

git checkout -b feature/merge-project2-into-project1
git push origin feature/merge-project2-into-project1

Step 7: Clean up

Test your code to ensure everything builds and runs as expected now that it is all in one repository. Create a pull request and review all the changes to ensure nothing gets changed that shouldn’t be.

When you look at your PR, it will look like a lot of code has been added. However, if you look closely at the Git history of those files, you will see that the history has been preserved from the original repository. You can remove the temporary project2 remote once you no longer need it (git remote remove project2).

Conclusion

This is still one of the simplest ways to combine two codebases without throwing away history. Use it when consolidating services or folding a spike repo into the main project; open a PR so reviewers can see the merge conflicts and folder layout before it lands on the default branch.

Once the histories live in one repo, automated promotion helps: see automatic pull requests for GitHub Actions and Azure DevOps patterns, and using GitHub Actions if you are wiring CI around the merge.

If you have enjoyed this article and want to get a monthly email with all my latest articles, please sign up for my newsletter . If you have any questions or comments, please feel free to reach out or leave a comment below.

The Pragmatic Programmer

funkysi1701@gmail.com (funkysi1701) — Mon, 24 Feb 2025 20:00:00 +0000

I have been reading The Pragmatic Programmer and I have to say it is a fantastic book. It is full of great advice and tips for programmers. I highly recommend it to anyone who is a programmer at any level.

Lots of the advice is common sense and things I already do, but there are also lots of things I know in the back of my mind that I should be doing. So reading it has been a great reminder of those things.

Here is the complete list of tips that can be found in the book (I am reading the 20th anniversary edition, so these might be slightly different if you are looking at the original edition):

Care About Your Craft
Think! About Your Work

A Pragmatic Philosophy

You Have Agency
Provide Options, Don’t Make Lame Excuses
Don’t Live with Broken Windows (I blogged about this in 2015)
Be a Catalyst for Change
Remember the Big Picture
Make Quality a Requirements Issue
Invest Regularly in Your Knowledge Portfolio
Critically Analyze What You Read and Hear
English is Just Another Programming Language
It’s Both What You Say and the Way You Say It
Build Documentation In, Don’t Bolt It On

A Pragmatic Approach

Good Design Is Easier to Change Than Bad Design
DRY - Don’t Repeat Yourself
Make It Easy to Reuse
Eliminate Effects Between Unrelated Things
There Are No Final Decisions
Forgo Following Fads
Use Tracer Bullets to Find the Target
Prototype to Learn
Program Close to the Problem Domain
Estimate to Avoid Surprises
Iterate the Schedule with the Code

The Basic Tools

Keep Knowledge in Plain Text
Use the Power of Command Shells
Achieve Editor Fluency
Always Use Version Control
Fix the Problem, Not the Blame
Don’t Panic
Failing Test Before Fixing Code
Read the Damn Error Message
“select” Isn’t Broken
Don’t Assume It - Prove it
Learn a Text Manipulation Language

Pragmatic Paranoia

You Can’t Write Perfect Software
Design with Contracts
Crash Early
Use Assertions to Prevent the Impossible
Finish What You Start
Act Locally
Take Small Steps - Always
Avoid Fortune Telling

Bend, or Break

Decoupled Code is Easy to Change
Tell, Don’t Ask
Don’t Chain Method Calls
Avoid Global Data
If it’s Important Enough to be Global, Wrap It in an API
Programming is About Code, But Programs Are About Data
Don’t Hoard State; Pass It Around
Don’t Pay Inheritance Tax
Prefer Interfaces to Express Polymorphism
Delegate to Services: Has-A Trumps Is-A
Use Mixins to Share Functionality
Parameterize Your App Using External Configuration

Concurrency

Analyze Workflow to Improve Concurrency
Shared State is Incorrect State
Random Failures Are Often Concurrency Issues
Use Actors for Concurrency Without Shared State
Use Blackboards to Coordinate Workflow

While You Are Coding

Listen to Your Inner Lizard
Don’t Program by Coincidence
Estimate the Order of Your Algorithms
Test Your Estimates
Refactor Early, Refactor Often
Testing is Not About Finding Bugs
A Test is the First User of Your Code
Build End-to-End, Not Top-Down or Bottom-Up
Design To Test
Test Your Software, or Your Users Will
Use Property-Based Tests to Validate your Assumptions
Keep it Simple and Minimize Attack Surfaces
Apply Security Patches Quickly
Name well; Rename When Needed

Before the Project

No One Knows Exactly What They Want
Programmers Help People Understand What They Want
Requirements are Learned in a Feedback Loop
Work with a User to Think Like a User
Policy is Metadata
Use a Project Glossary
Don’t Think Outside the Box - Find the Box
Don’t Go into the Code Alone
Agile is Not a Noun; Agile is How You Do Things

Pragmatic Projects

Maintain Small, Stable Teams
Schedule It to Make it Happen
Organize Fully Functional Teams
Do What Works, Not What’s Fashionable
Deliver When Users Need It
Use Version Control to Drive Builds, Tests and Releases
Test Early, Test Often, Test Automatically
Coding Ain’t Done ‘Til All the Tests Run
Use Saboteurs to Test Your Testing
Test State Coverage, Not Code Coverage
Find Bugs Once
Don’t use Manual Procedures
Delight Users, Don’t Just Deliver Code
Sign your Work

Professional Ethics

First, Do No Harm
Don’t Enable Scumbags
It’s Your Life

Understand and handle .NET exceptions

funkysi1701@gmail.com (funkysi1701) — Mon, 17 Feb 2025 20:00:00 +0000

While at NDC London I heard a great talk by Matt Burke about exceptions. I will share some of the points here.

The talk was based in part on the blog post Vexing Exceptions by Eric Lippert.

It defined four types of exceptions:

Fatal Exceptions
Boneheaded Exceptions
Vexing Exceptions
Exogenous Exceptions

Fatal Exceptions

These are exceptions that are thrown when the application is in an unrecoverable state. Examples of these are OutOfMemoryException and StackOverflowException. Don’t try and catch these kind of exceptions, just let the application crash.

Boneheaded Exceptions

These are exceptions that are caused by a bug in the code. These are the easiest to fix, as you just need to fix the bug. Examples of these are NullReferenceException and IndexOutOfRangeException. Boneheaded exceptions are a gift and it is the code telling you, that you have a bug to fix. Do throw these kind of exceptions, when someone messes up. They can be especially useful when someone else is consuming your API, you can throw an exception with a message that tells them what they did wrong.

Vexing Exceptions

These are exceptions that are thrown by the framework, and are hard to avoid. Examples of these are FormatException and InvalidOperationException. These are the hardest to fix, as they are thrown by the framework. You can’t fix the framework, so you have to work around them. You can’t avoid them, so you have to catch them. You can’t ignore them, so you have to handle them. You can’t fix them, so you have to work around them.

One example of this is the int.Parse() method, it will throw a FormatException if the string is not a valid integer. You can’t avoid this, so you have to catch it. Of course a better way to do this is to use int.TryParse() which will return a boolean if the parse was successful.

Exogenous Exceptions

These are exceptions that are thrown by external systems. Examples of these are IOException and SocketException. These are the hardest to fix, as they are thrown by external systems. You can’t fix the external system, so you have to work around them.

A recent example is concurrency problems, if you are processing data in a database and other systems could update it at the same time, you could get a concurrency exception. The data you have in memory might not reflect the real state of that data. You can’t avoid this, so you have to catch it. You can’t ignore it, so you have to handle it.

try
{
 // Do something that could throw an exception
}
catch (Exception ex)
{
 // Log the exception
 Log.Error(ex);
 throw ex; // Bad resets the stack trace
 throw; // Good keeps the stack trace 
}

Also don’t hide Exogenous Exceptions, if you catch an exception and don’t rethrow it, you are hiding the exception from the caller. I have seen code that uses the mediator pattern, it will call a method and not return to the original caller that something went wrong. This is bad, as the original caller needs to know that something went wrong.

What is new with C#

funkysi1701@gmail.com (funkysi1701) — Mon, 10 Feb 2025 20:00:00 +0000

I was lucky enough to hear Mads Torgersen (The Lead Designer of the C# language) speak at NDC London about some of the plans the team has for the next version of C#. Many of these new features are in the preview stage, and can be enabled by using the c# preview flag in your csproj file. The C# team welcomes feedback on the different use cases for new feature, especially during these early previews. As this is a preview of new language features, don’t blame me if this all changes before it all ships in Novembers release!

<PropertyGroup>
 <LangVersion>preview</LangVersion>
</PropertyGroup>

Dictionary Expressions

This is an extension of the existing collection expressions that we have had since C# 12, but this time for dictionaries.

The syntax is going to look a bit like

IList<int> foo = [1, 2, 3];
IDictionary<int, string> bar = [1: "one", 2: "two", 3: "three"];

Dictionary Expressions

Simple lambda parameters with modifiers

WithOut w1 = (string s) => s.Length;
WithOut w2 = (s) => s.Length;
WithOut w3 = (string s, out int i) => i = s.Length;
WithOut w4 = (s, out i) => i = s.Length;

Simple lambda parameters with modifiers

Unbound generic types in nameof

var t = typeof(List<>);
var n = nameof(List<>);

Unbound generic types in nameof

Null conditional assignment

var c = C.GetOne();
c.P = "Hello";
c.E += () => { };
c?.P = "Hello";
c?.E += () => { };

Null conditional assignment

Partial events and constructors

partial class Partials
{
 public partial void M(int i);
 public partial string P { get; }
 public partial string this[int i] { get; }
 public partial event Handler? E;
 public partial Partials();
}

Partial events and constructors

Field access in auto properties

class Fields
{
 public string? FirstName { get; set; }
 public string? LastName { get => field; set => field = value?.Trim(); }
}

note the field keyword is a potential breaking change if you have field variables in your code.

Field access in auto properties

This last one revealed a couple of gems of information that I found interesting. Creating a class called var can essentially disable the var keyword, and if you declare a variable called _ it can disable the discard operator. Neither of these things I would want to do in production code, but interesting that the language allows them.

Extensions

We have had extension methods for a while, but what about extension members?

Extension members

public static class Enumerable
{
 // New extension declaration
 extension(IEnumerable source) { ... }

 // Classic extension method
 public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source) { ... }

 // Non-extension member
 public static IEnumerable<int> Range(int start, int count) { ... }
}

This was a fascinating look at what is coming up for C#, and it will be interesting to see how these new ways of writing code will get adopted.

Volunteering at NDC London

funkysi1701@gmail.com (funkysi1701) — Mon, 03 Feb 2025 20:00:00 +0000

I have just come home from volunteering at NDC London. It was a great experience and I learned a lot. I met some great people and had a lot of fun. I can’t wait to go back next year.

You may have heard of NDC London before. It is a conference for software developers. It is held in London every year and attracts people from all over the world. The conference covers a wide range of topics, with a strong focus on .NET. I have heard about the conference for years and always wanted to go, but with ticket prices in the thousands, it was out of reach for me.

Late last year, I saw a contact on social media mention that volunteering at NDC was a good way to go to the conference for free. I had heard that this was an option before, but hadn’t acted upon it. So I sent a quick email to the conference organizers. I didn’t expect I would get on the team, but they emailed back and said I was on the team, and asked what was my t-shirt size. I was so excited!

The event is held at the Queen Elizabeth II Centre , which is a great venue, right next to Big Ben and Westminster Abbey. The conference is spread over a whole week, with 2 days of workshops and 3 days of talks. Volunteers are only needed for the 3 days of talks, however, there was an intro meeting the day before.

As a volunteer, you don’t get paid, so I needed to arrange my own transport to London and accommodation. It being London, I knew the tube network was a quick and easy way to get around, so I could search for a reasonably priced hotel that was near the venue.

The intro meeting was on Tuesday evening, at 5.30 pm. I arrived a bit early and unfortunately, I wasn’t very clear about why I was there so I was told to wait and the meetup would go upstairs soon. The London .NET user group was having a session at 5 pm with Mads Torgersen (the C# language designer), but luckily I double-checked and got to wait with the right people. However, this was not a bad thing, as I got to see some of the .NET team walk past, like Steve Sanderson and of course Mads Torgersen who was going to the meetup.

Once the intro meeting started, we unboxed the hoodies that every attendee was given. These ranged in size from XS to XXXL, we also learned how the registration process worked. Scan a QR code, print off the ticket, stick it to the lanyard, and issue it to the attendee. I also found out that there was a decent Yorkshire contingent, some I had met from York and Leeds user groups. We had a tour of the venue, the conference was on floors 3, 4, and 5. The top floor had a great view of Big Ben and Westminster Abbey. We were also issued our own T-shirt and hoodies, which were purple and said NDC Crew on them along with our lanyard passes.

It was an early morning, we needed to be at the venue for 7 am, ready to welcome 900+ people to the conference when the doors opened at 8 am. I helped man the hoodies, handing out XXL to any attendees who wanted them. There was a steady stream of people registering, however, I didn’t feel overwhelmed. By the time we had finished at registration, the keynote with Scott Hanselman was about halfway through, so I went to get a coffee and some breakfast and had a look at the schedule for the day. I was assigned to help out with the afternoon sessions so I was free to attend any sessions I liked in the morning.

For my afternoon duties, I needed to report back when the speaker had arrived and count up the number of green/amber/red cards for the session. At NDC feedback for the different speakers is submitted by the attendees by putting cards of different colours in a box. Green for good, amber for ok, red for bad. Throughout the different talks I attended there was always a good proportion of green cards, indicating the high quality of the speakers at NDC.

Wearing a purple NDC Crew hoodie, gave me a certain amount of confidence, I walked among many of the sponsors and chatted to a few. Elastic Search had a stall, and I mentioned my recent experience at work with them. At some conferences, I can feel a bit out of place, but at NDC being a volunteer, I had an automatic group of friends to chat to, the other volunteers, and this also helped me speak with one or two of the speakers. I enjoyed saying hello to Richard Campbell, who I had listened to on the .Net Rocks and RunAs Radio podcasts for years. I told him he had sent me a mug, and he mentioned it was a collector’s item now.

At the end of the first day, I was invited to the speaker dinner, which was a great experience. I got to chat with some of the other volunteers. I had a great time and it was free food and drink so I can’t complain.

While I was volunteering, I was often hanging out with the other volunteers. We had a great time, and I made some new friends. We had a lot of fun, and I learned a lot, which I hope to blog about soon. I can’t wait to go back next year.

Set up Grafana for .NET with Docker

funkysi1701@gmail.com (funkysi1701) — Mon, 27 Jan 2025 20:00:00 +0000

Grafana is an open-source analytics and monitoring platform that lets you query, visualise, and alert on metrics. It pairs well with Prometheus for scraping application endpoints. This post walks through a Docker Compose stack that monitors a simple .NET API.

Setting up Grafana

To visualise metrics data, we need a few components. The .NET application exposes a /metrics endpoint. Prometheus scrapes it on an interval and stores the samples. Grafana then queries Prometheus and renders dashboards.

Docker Compose File

Start with a Compose file for Prometheus and Grafana. Pin image tags so rebuilds stay reproducible (bump them when you deliberately upgrade):

services:
 prometheus:
 image: prom/prometheus:v3.4.0
 ports:
 - 5431:9090
 volumes:
 - ./prometheus/:/etc/prometheus/
 - prometheus:/prometheus 

 grafana:
 image: grafana/grafana:11.6.0
 expose:
 - "3000"
 ports:
 - 3000:3000
 volumes:
 - grafana:/var/lib/grafana

volumes:
 prometheus:
 grafana:

This brings up Grafana and Prometheus, maps ports, and mounts config/data volumes.

Prometheus Configuration

Next, create a prometheus.yml file to configure Prometheus:

global:
 scrape_interval: 15s
 evaluation_interval: 15s 

scrape_configs:
 - job_name: 'api'
 scheme: 'https'
 tls_config:
 insecure_skip_verify: true
 scrape_interval: 10s
 scrape_timeout: 5s
 static_configs:
 - targets: ['api.example.com:443']

This configures how often the /metrics endpoint should be scraped. By default Prometheus expects something like http://api.example.com/metrics. Because my API ran under HTTPS I set scheme to https and skipped TLS verification in this lab setup. scrape_interval is how often the endpoint is scraped; if scrape_timeout is omitted the global value is used.

More information about configuring Prometheus can be found here .

Grafana Config

You can now log into Grafana on http://localhost:3000 with the default username and password of admin/admin. You will be prompted to change the password. Add a Prometheus data source next. Prometheus is published on the host as http://localhost:5431 , but from another container you usually cannot use localhost for a sibling service.

If Grafana needs to reach Prometheus on the host (for example when Prometheus is published only to the host network), use host.docker.internal (Docker Desktop and many Linux setups with the host-gateway mapping): http://host.docker.internal:5431 . Prefer the Compose service name (http://prometheus:9090) when both services share the same Compose network.

Dashboard

The next thing we need to do is build a dashboard — the .NET team has done much of the hard work. They published a Grafana dashboard you can import.

You can also build panels yourself in the Grafana UI (graphs, gauges, and other visualisations).

Metrics endpoint

If your .NET application is using .NET Aspire, this /metrics endpoint is often already set up for you. Look in Extensions.cs in your ServiceDefaults project for something like the following (you need the NuGet package OpenTelemetry.Exporter.Prometheus.AspNetCore):

public static WebApplication MapDefaultEndpoints(this WebApplication app)
{
 // The following line enables the Prometheus endpoint (requires the OpenTelemetry.Exporter.Prometheus.AspNetCore package)
 app.MapPrometheusScrapingEndpoint();
}

If you are not using .NET Aspire, you can add app.MapPrometheusScrapingEndpoint() to your Program.cs file (with the same package referenced).

Conclusion

With Compose, Prometheus, and Grafana in place you can scrape a .NET /metrics endpoint and watch live dashboards — useful for latency, exceptions, and ASP.NET Core built-in meters. Happy monitoring!

Prefer classic host and service checks? Try monitoring with Nagios in Docker . If Aspire already wires OpenTelemetry for you, getting started with Aspire is a useful companion to the metrics endpoint notes above.

If you have enjoyed this article and want to get a monthly email with all my latest articles, please sign up to my newsletter . If you have any questions or comments, please feel free to reach out or leave a comment below.

Adding Elasticsearch with .Net Aspire

funkysi1701@gmail.com (funkysi1701) — Mon, 20 Jan 2025 20:00:00 +0000

A few weeks ago I talked about .Net Aspire , well lets take a look at how we can use it with Elasticsearch. Elastic search is a powerful search engine that can be used to index and search data. It is built on top of Lucene and provides a powerful way to search through your data.

Aspire allows dependencies like elasticsearch to be added to a project programmatically. Lets look at how this can work.

Add this nuget package to your AppHost project (as of writing this is a preview package):

<PackageReference Include="Aspire.Hosting.Elasticsearch" Version="9.0.0-preview.5.24551.3" />

In your AppHost project, add the following code to your Program.cs file:

var elasticsearch = builder
 .AddElasticsearch("elasticsearch");

Now if you run your project it will add an elasticsearch containter to your project. A common way to administer elasticsearch is to use Kibana. You can add this to your project by adding the following code to your Program.cs file:

var kibana = builder
 .AddContainer("kibana", "kibana", "8.15.3") // Add Kibana from the image kibana, and tag 8.15.3 and give it a name kibana
 .WithReference(elasticsearch) // Add a reference to the elasticsearch container
 .WithEndpoint(5601, 5601); // Expose a port so you can connect

Now if you run your project you will have an elasticsearch and kibana container running. You can access kibana by going to http://localhost:5601, and elasticsearch by going to http://localhost:9200.

Troubleshooting Kibana

However when I do that I get the error Kibana server is not ready yet. Looking at the kibana container logs, I see the following error:

2025-01-19T21:42:13 [2025-01-19T21:42:13.558+00:00][WARN ][plugins.security.config] Generating a random key for xpack.security.encryptionKey. To prevent sessions from being invalidated on restart, please set xpack.security.encryptionKey in the kibana.yml or use the bin/kibana-encryption-keys command.
Unable to retrieve version information from Elasticsearch nodes. security_exception

This is due to the security settings in Elasticsearch. To fix this, you can turn off this security feature by enabling an environment variable:

var elasticsearch = builder
 .AddElasticsearch("elasticsearch")
 .WithEnvironment("xpack.security.enabled", "false");

As Aspire is only running locally, this is fine, but in a production environment, you would want to secure your Elasticsearch and Kibana instances.

Using Elasticsearch in Your Project

Now that you have Elasticsearch added to your project, how can you use it? In the .NET project that wants to connect and interact with Elasticsearch, you can add the following NuGet package:

Aspire.Elastic.Clients.Elasticsearch (version 9.0.0-preview.5.24551.3 as of writing)

In the Program.cs file of your .NET project you can add the following code:

builder.AddElasticsearchClient("elasticsearch");

No need to specify any complex connection strings or settings, Aspire will handle all of that for you.

This is pretty much all of the Aspire specific code you need, but lets have a quick look at indexing some data and returning it with a search. Elastic Search has extensive documentation on how to do this with the dotnet libraries.

To index some data you can use the following code:

 await _client.Indices.CreateAsync("searchindex", cancellationToken); // Create an index called searchindex

 var documents = context.Episode.ToList(); // Get the documents you want to index from Entity Framework or any other source

 await _client.IndexManyAsync(documents, index: "searchindex", cancellationToken); // Index the documents into the searchindex index

ElasticsearchClient can be injected in via dependency injection, again no need to specify any connection strings or settings.

To search for data you can use the following code:

 // Create a search request with a wildcard query which searches in the title field of your indexed documents.
 var searchRequest = new ESSearchRequest("searchindex")
 {
 From = 0,
 Size = 10,
 Query = new WildcardQuery("title") { Value = $"*{SearchQuery}*" },
 };
 // Execute the search request and get the response.
 var response = await _client.SearchAsync<Episode>(searchRequest, cancellationToken);

 if (response.IsValidResponse)
 {
 // Return the documents from the response.
 return response.Documents.ToList();
 }

Conclusion

By following these steps, you can successfully integrate Elasticsearch and Kibana into your .NET Aspire project. This setup allows you to leverage powerful search and analytics capabilities in your application. Remember to secure your instances in a production environment to ensure data safety.

NuGet central package management

funkysi1701@gmail.com (funkysi1701) — Mon, 13 Jan 2025 20:00:00 +0000

Managing dependencies in .NET projects can become complex, especially when dealing with multiple projects that share common packages. NuGet Central Package Management (CPM) is a feature that simplifies this process by allowing you to manage package versions centrally.

What is NuGet Central Package Management?

NuGet Central Package Management allows you to define and manage package versions in a central location, rather than specifying them individually in each project file. This approach ensures consistency across projects and simplifies the process of updating package versions.

Setting Up Central Package Management

To get started with Central Package Management, follow these steps:

Create a Directory.Packages.props File: This file will contain the central package version definitions. Create this file in the root directory of your solution.

Define Package Versions: In the Directory.Packages.props file, define the package versions you want to manage centrally. For example:

<Project>
 <PropertyGroup>
 <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
 </PropertyGroup>
 <ItemGroup>
 <PackageVersion Include="Newtonsoft.Json" Version="13.0.1" />
 <PackageVersion Include="Serilog" Version="2.10.0" />
 <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="9.0.0" />
 <PackageVersion Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.0" />
 </ItemGroup>
</Project>

Update all your csproj files: In each project file (.csproj), remove the version number information:

<ItemGroup>
 <PackageReference Include="Newtonsoft.Json" />
 <PackageReference Include="Serilog" />
 <PackageReference Include="Microsoft.EntityFrameworkCore" />
 <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" />
</ItemGroup>

Benefits of Central Package Management

Using Central Package Management offers several benefits:

Consistency: Ensures that all projects use the same package versions, reducing the risk of version conflicts.
Simplified Updates: Updating a package version in the central file automatically updates it across all projects.
Reduced Maintenance: Simplifies the process of managing package versions, especially in large solutions with many projects.

If for any reason you want to disable Central Package Management, you can set the ManagePackageVersionsCentrally property to false in the Directory.Packages.props file, or in the csproj file if you only want to disable for a single project.

Conclusion

NuGet Central Package Management simplifies the process of managing package versions across multiple projects in a .NET solution. By defining package versions in a central file, you can ensure consistency, simplify updates, and reduce maintenance efforts. Give it a try in your next .NET project to experience the benefits firsthand.

For more information, visit the official NuGet documentation .

Setting Up Nagios Monitoring with Docker

funkysi1701@gmail.com (funkysi1701) — Mon, 06 Jan 2025 20:00:00 +0000

A long time ago in my SysAdmin days, I was a big fan of Nagios . Recently, I decided to revisit it and see if I could run it in a Docker container to monitor my local network. This guide will walk you through the process of setting up Nagios monitoring using Docker.

Finding a Docker Image for Nagios

First, we need to find a suitable Docker image for Nagios. The manios/nagios image looks like it should do the job.

Running the Nagios Docker Container

The basics of running this container are as follows:

docker run -d --name nagios -p 8080:80 manios/nagios

This command will pull the Nagios image from Docker Hub and run it in a container, mapping port 80 in the container to port 8080 on your host machine.

docker run -d --name nagios \
 -v /path-to-nagios/etc/:/opt/nagios/etc/ \
 -v /path-to-nagios/var:/opt/nagios/var/ \
 -v /path-to-nagios/ssmtp.conf:/etc/ssmtp/ssmtp.conf \
 -v /path-to-custom-plugins:/opt/Custom-Nagios-Plugins \
 -p 8080:80 \
 manios/nagios

I prefer running via docker compose, which looks like this:

 nagios:
 image: manios/nagios:latest
 container_name: monitoring_nagios
 ports:
 - 8081:80
 restart: always
 volumes:
 - ./nagios/localhost.cfg:/opt/nagios/etc/objects/localhost.cfg
 - ./nagios/windows.cfg:/opt/nagios/etc/objects/windows.cfg
 - nagios_data:/opt/nagios/var/
 environment:
 - NAGIOSADMIN_USER=nagiosadmin
 - NAGIOSADMIN_PASS=nagiosadmin
 - NAGIOS_TIMEZONE=UTC
 - NAGIOS_WEB_USER=nagiosadmin
 - NAGIOS_WEB_PASS=nagiosadmin

Accessing the Nagios Web Interface

Once the container is running, you can access the Nagios web interface by navigating to http://localhost:8080 in your web browser. You should see the Nagios login page.

Configuring Nagios

To configure Nagios, you’ll need to edit the configuration files located in the container. You can do this by accessing the container’s shell:

docker exec -it nagios /bin/bash

From here, you can navigate to the Nagios configuration directory and make the necessary changes:

cd /opt/nagios/etc

Adding Hosts and Services

To monitor your local network, you’ll need to add hosts and services to the Nagios configuration. This involves editing the configuration files and adding each host and service you want to monitor.

I have added a few extra hosts to the localhost.cfg file to monitor my router, and a few other devices on my network. I have also added a Volume to store the nagios data, so after a restart of the container the data is still there.

Lets have a look at how hosts and services are defined in the config files.

define host{
 use linux-server
 host_name router
 alias router
 parents localhost; Hosts that this host is dependent on 
 address 192.168.2.1; IP Address or DNS name of the host
}

define service{
 use local-service,graphed-service
 host_name localhost, router
 service_description PING
 check_command check_ping!100.0,20%!500.0,60%
}

When making changes to your config files it is useful to check the config is valid. To do this with the docker file you can run the following command:

docker exec -it mynagioscontainer bin/nagios -v etc/nagios.cfg

It may have been 10 years since I last looked at Nagios, but the UI hasn’t changed much. Host are checked if they are Up or Down, and every Host can have a number of services associated with it and this are checked if they are Up or Down.

Conclusion

By following these steps, you can set up Nagios monitoring using Docker to keep an eye on your local network. Nagios is a powerful tool for network monitoring, and running it in a Docker container makes it easy to deploy and manage. Happy monitoring!

For application metrics and dashboards rather than host ping checks, see setting up Grafana with Prometheus. I also wrote about loving Nagios the first time around — the UI has barely moved since.