DEV Community: Chris McKelt

dapr

Chris McKelt — Thu, 10 Jul 2025 12:54:26 +0000

Using Azure to setup a new blog and domain

Chris McKelt — Sun, 03 Jan 2021 14:41:10 +0000

Intro

Here is a quick way to setup a new WordPress blog with a custom domain on Azure (optionally using free using credits).

Azure Resources Overview

Resources used to setup the blog may be seen below. These were created within a single resource group called ‘blog’

WordPress Setup

After logging into Azure go the the marketplace and search for WordPress

Click create and begin to enter the details for your blog. All resources below were created in a new resource group called ‘blog’

Create a new App Service Plan

Here we are using the cheapest pricing tier that allows a custom domain: ‘B1 Basic’ Tier

Configure a new database server using the ‘Basic’ pricing tier

After clicking the create button a new WordPress App Service will be deployed and available to configure on_ YourBlogSite.azurewebsites.net_

Navigate to the website and configure your WordPress instance.

Next we will setup a custom website domain to use for the blog using App Service Domains. App Service domains are custom domains that are managed directly in Azure. They make it easy to manage custom domains for Azure App Service.

Create your App Service Domain and choose a TLD domain name for your website.

Enter your contact information required by GoDaddy for domain registration and Azure DNS to host the domains. In addition to the yearly domain registration fee, usage charges for Azure DNS apply. For information, see Azure DNS Pricing.

Create you App Service Domain, it may take a while for the DNS to propagate and be ready for use

Go to your App Service Domain and add a hostname binding pointing to the App Service that hosts your WordPress blog.

You should now be able to browse to your custom domain and see your WordPress site. Thats it!

Conclusion

So we now have a WordPress website setup with a custom domain without leaving the Azure portal.

Next steps will be:

Create a free SSL certificate via Lets Encrypt to host the site under SSL

Follow Azure guidelines to improve WordPress performance

Please let us know how you go with setting up your own site.

Happy blogging!

Azure IoT Edge – using Grafana on the Edge

Chris McKelt — Sat, 02 May 2020 03:37:06 +0000

Series

Part 1 - dotnet vs python vs node - temperature emission - who is cooler?
Part 2 - Developing modules
Part 3 - Custom Containers using Apache Nifi
Part 4 - Custom Module using TimescaleDB
Part 5 - Custom Module using Grafana

Intro

This is part 5 in a series starting here that runs through building an Azure IOT Edge solution. This post will run through setting up Grafana to visualise temperature readings sent from the dot net, python and node custom edge modules.

The code is located at: https://github.com/chrismckelt/edgy

Grafana is the open source analytics and monitoring solution for every database

Steps to add the module

1. add a new custom module

2. add a new deployment file just for Grafana (and amend the full solution file)

3. create the docker file

FROM grafana/grafana:latest

# login with admin and below password to web interface

ENV GF_SECURITY_ADMIN_PASSWORD [YOUR_GRAFANA_PASSWORD_HERE]

ENV GF_AUTH_LDAP_ENABLED=false

ENV GF_DATABASE_TYPE postgres

ENV GF_DATABASE_HOST timescaledb

ENV GF_DATABASE_NAME grafana

ENV GF_DATABASE_USER grafana

ENV GF_DATABASE_PASSWORD [YOUR_DATABASE_PASSWORD_HERE]

COPY ldap.toml /etc/grafana/

COPY custom.ini /etc/grafana/

4. create the custom.ini

make sure to enter the database password on line 75

5. build and run IoT Edge solution in simulator

6. Navigate to http://localhost:8082/ and login (admin + your grafana password)

The Grafana setup board should appear as below

7. Add data source –> PostgreSQL

8. Add a dashboard query & set the query as below

A time series graph will display the 3 temperature readings over time.

Outro

Here we have added Grafana to our IoT Edge solution and created a dashboard from the data stored in TimescaleDB. The generated temperature sent from the 3 modules is analysed by Apache Nifi. When the temperature is greater than 25 degrees a request is sent back to the specific module to activate the air conditioner, which makes the temperature randomly decrease over time.

Think I would prefer the Python room as it appears the coolest!

Azure IoT Edge – using TimescaleDB on the Edge

Chris McKelt — Sun, 12 Apr 2020 06:41:47 +0000

Series

Intro

This is part 4 in a series starting here that runs through building an Azure IOT Edge solution. This post will run through setting up TimescaleDB to store data published from the dotnet, python and node temperature modules.

The code is located at: https://github.com/chrismckelt/edgy

TimescaleDB: An open-source database built for analysing

time-series data with the power and convenience of

SQL — on premise, at the edge or in the cloud.

Steps to add the database

1. add the custom module

2. add the section to the deployment file

Expose the internal port 5432 that TimescaleDB uses to 8081 for external container use

3. create the docker file

4. create the database, login and schema

5. run the container and insert data from another module

select * from “table_001” where Isairconditioneron = 0 ORDER BY “Timestamp” DESC LIMIT 100;

Outro

Now we have data being saved into the database we can move onto displaying it visually via Grafana in the next post.

Azure IoT Edge – Using Apache Nifi as a 3rd party container

Chris McKelt — Thu, 02 Apr 2020 16:33:30 +0000

Series

Intro

=====

This is part 3 in a series starting here that runs through building an Azure IOT Edge solution. This post will run through setting up a 3rd party docker container for an edge deployment.

The code is located at: https://github.com/chrismckelt/edgy

In order to manage data flow & logic on the edge we will deploy a data orchestrator. There are quite a few choices on the market – for this demo we will use Apache Nifi https://nifi.apache.org/.

Apache Nifi describes itself as ‘An easy to use, powerful, and reliable system to process and distribute data.’

What will this module do?

The Nifi module will listen to the dot net, python & node module messages and when a temperature exceeds 25°C it will publish a message to activate the air conditioning. The over heating module will receive the message and turn the air conditioning on, thus decrease the temperature.

This work was inspired by the following project:

https://github.com/iotblackbelt/nifimodule

Setting up Nifi

To connect Nifi to the edge hub MQTT/AMQP broker (and not using the inbuilt SDKs with code), we need to authenticate with self signed certificates.

The easiest way to use self signed certificates for Azure IoT Edge is to follow this tutorial https://docs.microsoft.com/en-us/azure/iot-edge/tutorial-machine-learning-edge-05-configure-edge-device.

I use the docker image provided in that tutorial to generate my self signed certs. After following the tutorial I upload the ROOT CA to the Azure IoT Hub. After verification it should appear as below:

When working locally with the simulator you will use the generated certs from VS Code. These are found at C:\ProgramData\iotedgehubdev

Deployment files

For debugging purposes I made a deployment file that runs only the DotNetGenerator & Nifi. The sections below are also in the full local debug and production template.

Nifi config setup

When the Nifi docker file starts it will execute a script to do the following:

copy existing files from the local computer using docker bind from c:/config to /config
copy the self signed certificates to the Java cert store
restart Nifi so the certs and new configuration apply

Nifi authentication

To connect and publish messages to the MQTT broker we add the following processors in our Nifi flow

ConsumeMQTT
PublishMQTT

Upon adding a processor you will need to enter the connection details and configure a SSL Context Service to connect to the edge hub broker.

SSL Context Service setting (certs used are stored in the Java cert store)

Settings

To generate a SAS token, right click on the device and select ‘Generate SAS Token for Device’

Nifi logic to air con control

Using the inbuilt IoT routing system temperature payloads published from dot net, python & node will be pushed to Nifi.

Nifi checks if the temperature recording exceeds 25°C. When this occurs it will publish its own message which is routed back to the overheating module requesting it to turn on the air con.

In Nifi this translates to the following processor flows (probably a better way to do this – Nifi experts?)

Nifi flows

Running the solution locally

Upon starting the solution each module will publish a temperature starting at 20°C . Nifi will receive each message via the Consume MQTT processor. Viewing the data provenance shows all received messages:

The modules keep publishing increasing temperatures until Nifi received a temperature over 25°C. Nifi then publishes a message requesting the respective module (e.g. PythonDataGenerator) to decrease the temperature (turn on the air con).

Watch out when publishing your container to ACR

Be careful when publishing your local containers to your remote container registry. I was publishing direct from my machine to my Azure Container Registry. Meanwhile the environment variables were set to look for certificates in the wrong place. So Nifi would not authenticate.

Outro

Here we have shown how to build and deploy a 3rd party container in our edge solution. Once we have the installed the custom certificates Nifi can authenticate to the edge hub and send/receive messages.

AZURE IOT EDGE – Developing custom modules

Chris McKelt — Tue, 10 Mar 2020 02:00:04 +0000

Series

Intro

This is part 2 in a series starting here that runs through an Azure IOT Edge solution located at: https://github.com/chrismckelt/edgy

This part will cover developing and running custom modules written in C#, Python and NodeJS.

It will focus on commands available in the VS Code interface rather than command line arguments as seen at: https://aka.ms/iotedgedev

Azure IoT SDKs

Azure IoT Edge has a number of SDKs for module development in your favourite language. The SDK code will handle setting up environment variables and provide the boiler plate code necessary to send and receive messages using multiple protocols & channels (e.g. MQTT, AMQP)

Setting up VS Code to run the local simulator

Given the solution is cloned locally and Azure is setup with our IOT Hub we can configure a device to act as a local simulator.

Select IOT Hub & choose your IOT Hub

Create IOT Edge Device - I have named my local device ‘LocalSimulator ‘

Setup IOT Edge Simulator – this will create you edge certs

This will generate and install certificates for local development in the following folder & also install the for you note://run VS Code as admin for this

Creating a module for our solution

Right click on the modules folder and select ‘Add IoT Edge Module’.

This will then ask a module name & language (C,C#,Java,Node.js, Python)

This post will focus on the data generator/recorder modules below:

Data Generators

The demo code shows 3 ‘data generator’ modules written in C#, Python & Node JS.

Each module publishes a message every second simulating temperature capture. Properties of the sent message are:

In C# connecting to the Edge Hub and sending messages can be seen in the following code:

Data Recorders

3 modules in matching languages subscribe to their respective modules published messages

Messages received are deserialized from JSON format to a POCO and then saved in a database.

Routes

In order to route messages between modules we use the inbuilt route system in our deployment template file.

Web App – Viewer module

Finally to view the messages from a web page I have modified an existing demo to that uses SignalR view all messages sent to it from the below routes:

When running the solution you can view all published messages on the web page below

Outro

Here was a basic overview of an demo solution to create and build your own custom IoT Edge modules.

Next we will introduce an existing docker container (Apache Nifi) to act as a data orchestrator. This will subscribe to all 'Payload' messages and publish a message to ‘turn off’ the air conditioner when the temperature is too high.

Azure IoT Edge - dotnet, node python

Chris McKelt — Thu, 13 Feb 2020 13:00:51 +0000

Series

Intro

This code will run through creating an end to end demo of building & deploying an Azure IoT Edge solution.

Code for this example lives here

https://github.com/chrismckelt/edgy

Whats the demo?

This solution demonstrates an air-conditioning monitoring system where 3 room sensors are publishing their temperature over time. When a room gets too hot the air conditioner for that room is turned on. Once the room is cooled it is turned off.

Three ‘data generator’ modules publish a message with the following properties.

Timestamp
Temperature – room temp in Celsius
IsAirConditionerOn – true/false
TagKey – room name (in this case dotnet, node, python)

Three ‘data recorder’ modules subscribe to the published temperature messages and save the data in a time series database.

A custom module will listen to all temperature messages and analyse when a room is too hot. Sending a message to turn the rooms air conditioner on.

Demo Focus Areas

show local debug/development options & remote/real deployment
how to create and configure an Azure IOT Hub environment in Azure using Azure CLI scripts
coding custom modules in .Net, Python, NodeJS (sorry Java)
using existing Azure IoT Edge marketplace modules
using non-edge marketplace modules (docker images) to save data with Timescale
connecting a data flow engine ( Apache Nifi) to the Edge MQTT Broker
viewing the data through a Grafana dashboard.

Getting started

In order to develop solutions for the edge:

Read Developing custom modules
Setup your machine using the Azure IoT EdgeHub Dev Tool
I recommend installing these VS code extensions
I recommend using Portainer for docker management both locally & on the deployed edge solution

Portainer running on http://localhost:9000/

Solution Overview

Azure Setup

You will need an Azure IoT Hub setup in Azure. For this demo I am using the free tier

The IoT Hub Free Edition is intended to encourage proof of concept projects. It enables you to transmit up to a total of 8,000 messages per day, and register up to 500 device identities. The device identity limit is only present for the Free Edition.

To build the environment I have used the Azure CLI and created scripts found here. Run the top 3 on your selected subscription to create the artefacts in Azure below:

Modules

The code contains the docker build files , code & scripts to create the following modules

Code

Descriptions of folders and files

Folder / File	Description
config	automatically generate files from the deployment.templates.json (debug or prod) that are used to deploy the solution
modules	custom code, docker images for your IOT Edge solution
scripts	code to create the environment, build the code/docker images and deploy the solution
tools	certificate generator and other tools for solution support
.env	holds environment variables that populate the generated config files from the templates
deployment.debug.template.json	creates a file in the /config folder called 'deployment.debug.json' that populates environment variables, used for local development
deployment.prod.template.json	creates a file in the /config folder called 'deployment.prod.json' that populates environment variables, used for production like deployment

Solution Structure Overview

Azure IOT Edge Devices

The solution used 3 devices which will be setup in a future post.

1. Local Simulator

A simulated local environment using the Azure IoT Edge Hub Development simulator to run against the IOT Hub. When developing for the edge it is recommended not to install the real ‘IOT edge runtime’ on your machine but instead use the simulator.

2. Local Device

Linux Ubuntu machine hosted in VMWare on my local machine using Hyper V

https://docs.microsoft.com/bs-latn-ba/Azure/iot-edge/how-to-install-iot-edge-linux

3. Cloud Device

Linux Ubuntu hosted on Azure in our resource group created using this script

This uses the pre-existing Linux Ubuntu image from the Azure Marketplace with the runtime installed.

Once up and running VS Code will show the devices below.

Outro

Now we have a view of the setup, development environment & code, we can move onto the next post ‘Developing custom modules for Azure IoT Edge'

Using Azure Pipelines to restore a production database to another environment

Chris McKelt — Wed, 28 Aug 2019 14:31:17 +0000

Often we need a fresh copy of the production database in another environment (eg DEV/TEST/UAT).

Previously this was a tedious task involving getting a backup file, copying it to another location, restoring the database. Here is a solution to automate this process using Azure Pipelines.

User Story

Given a production database exists in subscription 1

When we do a release of the Azure Pipeline named ‘Refresh Database – DEV’

Then an copy of production is available in the DEV environment in subscription 2

And permissions are correct for the DEV environment

Pipeline Overview

For each environment that you wish to restore into create an Azure Pipeline with 3 stages.

Create variable groups that are scoped to specific stages

Each variable group contains deployment credentials that the specific stage will require to perform operations within the specific Azure Subscription.

Task 1 – Export

Create a PowerShell task to run a script and pass it the information for the production environment.

This runs against the production environment and creates a blog storage container that holds the exported BACPAC

View code for script production-export.ps1

Results in production once this script run should show the database BACPAC export

Task 2 – Import

Under the ‘import’ stage create a task that will import the BACPAC from the storage container in the production subscription. This uses both production and the environment credentials.

View code for script production-import.ps1

Task 3 – Sanitise

Create a 3rd task in the ‘Sanitise’ stage.

This will scramble any information you do not want in that environment (eg emails).

Also remove any Production SQL user account and replace them with environment specific

View code for script sanitise

TADA!

Running the pipeline now copies the database to the DEV environment. Typically after this will run a software build which will automatically apply schema changes currently in DEV in the database. Happy restoring!

NDepend code analysis

Chris McKelt — Tue, 02 Jul 2019 02:31:53 +0000

Intro

Recently I was asked to inspect and old VB.Net Windows Forms & SQL Server application to see determine its future life. Part of this technical review was analysing the code base and database structure.

To analyse the code base I used NDepend a well-known code quality analysis tool that has progressed by leaps and bounds since I last used it on the build server circa 2013 (then version 5). Now on version 2019.2.4

Application Overview

.Net 4.6 Windows Forms
SQL Server database where most of the logic resides (some in the GUI)

Setup

After installing NDepend you will get a menu icon in Visual Studio

Next setup the NDepend project for analysis. Within Visual Studio I select the projects and references I wish to include in the analysis. I am also able to include 2 extra DLLs that the vendor bundled with the application (but did not provide the source code)

Next tab I setup the Analysis settings and output location. This will enable NDepend to perform a time-based analysis to see how the solution has progressed/regressed since the last analysis.

Running the Analysis

The analysis tool may be run and viewed from inside Visual Studio or output as a HTML file (great for the build server report).

Application Metrics

Quality Gates

Dependency Graph

Dependence Matrix

Cyclomatic Complexity

Cyclomatic complexity is a software metric used to indicate the complexity of a program. It is a quantitative measure of the number of linearly independent paths through a program's source code. It was developed by Thomas J. McCabe, Sr. in 1976.

Cyclomatic complexity is computed using the control flow graph of the program: the nodes of the graph correspond to indivisible groups of commands of a program, and a directed edge connects two nodes if the second command might be executed immediately after the first command. Cyclomatic complexity may also be applied to individual functions, modules, methods or classes within a program.

KEY AREAS TO REDUCE COMPLEXITY ARE

CPS.UI.ProjectDataSetTableAdapters – code that handles retrieving/saving projects
CPS.UI.AdminDataSetTableAdapters – code that handles retrieving/saving admin

Ideally remove the use of data sets/adapters as a data access pattern and move to a modern-day best practice solution (entity framework, dapper).

The Abstractness versus Instability Diagram

The Abstractness versus Instability Diagram helps to detect which assemblies are potentially painful to maintain (i.e concrete and stable) and which assemblies are potentially useless (i.e abstract and instable).

Abstractness: If an assembly contains many abstract types (i.e interfaces and abstract classes) and few concrete types, it is considered as abstract.
Instability: An assembly is considered stable if its types are used by a lot of types from other assemblies. In this context stable means painful to modify.

Online documentation:

Definitions of related Code Metrics

Outro

This post is a Work in Progress – stay tuned as I update it over time and determine the best use for NDepend as I have requested changes by the Vendor to fix areas of the code. NDepend will be the tool I use that helps me guide the vendors code quality.

Reactive architecture with event grid

Chris McKelt — Sat, 27 Apr 2019 04:59:11 +0000

Azure Global Bootcamp – 27th April 2019

Click here to view slides

Predicting BS using ML.Net

Chris McKelt — Wed, 08 Aug 2018 02:48:33 +0000

Predicting BS using ML.Net

Machine learning is typically the realm for R/Python. But can .Net move into this space?

In this talk we will run through Microsoft’s new ML.Net framework including what it currently offers, how to build a learning pipeline and how to deploy a model to an Azure Service.

https://slides.com/chrismckelt/deck-451cdb94-a37d-47b7-9d49-6686065e7d03