
I decided to do something exciting and challenging for personal growth in my Data & AI area and posed myself the hypothesis: "Can I create a system that with a few publishers but a massive amount of subscribers?" with the constraints of:
* Should be easy to maintain (as much PaaS as possible)
* Should be easy to scale (can I autoscale? Container support? ...)
* Should be able to handle real-time data flows (a real pub/sub system!)

Thinking back this was something I actually encountered [before in 2014](https://github.com/sockjs/sockjs-node/issues/156) while working on the [Feedient](https://xaviergeerinck.com/projects/feedient) [socket implementation](https://github.com/Feedient/Server/blob/060184240f6028b4f29a76d884df9345561878dc/src/lib/socket.js), here however I was utilizing SockJS and only had a need for around 20k connected clients.

After doing some research on different Azure components (since it's my comfort zone), I came to the following conclusion:
* **Apache Kafka:** We can go high here, but it seems to be a [bad design](https://stackoverflow.com/questions/46284641/maximum-subscription-limit-of-kafka-topics-per-consumer). Next to that, it instantly starts off at 1.8k for a base HA cluster... 
* **Redis:** Might be possible! I could however not find anything about this (if anyone knows, please comment below :))
* Azure Event Hubs: Not possible, it will scale well but would be too expensive + there is a limit of around [3200 connections ](https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-quotas?WT.mc_id=DP-MVP-5004263)
    * Note: this could be increased through dedicated event hubs or contacting support but this would grow too expensive
* **Azure Event Grid:** [500 / topic](https://github.com/MicrosoftDocs/azure-docs/blob/master/includes/event-grid-limits.md)
    * Note: this could potentially be increased by multiple chained Event Grids, but this would cause too much implementation work on the moment
* **Azure Service Bus:** [2.000 subscriptions](https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-quotas?WT.mc_id=DP-MVP-5004263) on the basic or standard tier
    * Note: Again, can be increased but not ideal for the use case of growing towards > 10k connections.

After checking all of the above, I came to the conclusion that nothing in my existing skill portfolio is going to cover this... so I started my search online. After a bit of searching I came on a product calledd [emqx.io](https://www.emqx.io/) which sounded reasonable! And actually it was!

5 minutes later, I found and deployed the [docker container](https://hub.docker.com/u/emqx/) through the following command:

> Note: This is being deployed on a 1 GB RAM, 1 vCPU container instance on Azure

```bash
# Create container
az container create \
    -g General \
    --name emqx \
    --dns-name-label xemqx \
    --image emqx/emqx:latest \
    --cpu 1 \
    --memory 1 \
    --ports 1883 8883 8083 8084 8080 18083
```

With the port mapping being:

|Port|Name|isPrivate?|
|-|-|-|
|1883|MQTT|No|
|8883|MQTT/SSL|No|
|8083|MQTT/Websocket|No|
|8084|MQTT/Websocket/SSL|No|
|8080|Management API|No|
|18083|Dashboard|No|
|4369|Node Discovery|Yes|
|5369|Cluster RPC|Yes|
|6369|Cluster Channel|Yes|

After which I could open the dashboard by loading the FQDN:18083:

![./dashboard.png](./dashboard.png)

## Stress Testing - 10k Connections

Ok, so we now got our broker done. How can we actually start stress testing? Well for this I wrote a small script that we can just execute locally:

**client.js**

```javascript
const mqtt = require('mqtt')
const noOfClients = process.env.CLIENT_CONNECTIONS || 250; // How many clients to create?
const serverUrl = process.env.CLIENT_URL;

console.log(`Connecting ${noOfClients} to ${serverUrl}`);

for (let clientNo = 1; clientNo <= noOfClients; clientNo++) {
    // Unique MQTT Object per client
    const client = mqtt.connect(serverUrl)

    client.on('connect', () => {
        client.subscribe('test-message', (err) => {

            console.log(`Client Connected #${clientNo}`);
            if (err) {
                console.log(err);
                // client.publish('presence', 'Hello mqtt')
            }
        })
    })

    client.on('message', (topic, message) => {
        // message is Buffer
        console.log(`Client #${clientNo} Received: ${message.toString()}`)
        client.end(); // In this test we instantly end them
    })
}

console.log(`Connected ${noOfClients} clients`);
```

**package.json**

```json
{
  "name": "mqtt-tester",
  "version": "1.0.0",
  "description": "Testing mqtt subscriptions",
  "main": "client.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "async-mqtt": "^2.4.2",
    "mqtt": "^3.0.0"
  }
}
```

After executing this locally with `CLIENT_CONNECTIONS=10000 CLIENT_URL=mqtt://xemqx.northeurope.azurecontainer.io node client.js` I got to 10k connections! With a stable running `EMQX` service.

![./10k.png](./10k.png)

Next to that, I could also send to my subscribers by utilizing this small script (nothing fancy, I know):

**sender.js**

```javascript
const mqtt = require('mqtt')
const client = mqtt.connect('mqtt://xemqx.northeurope.azurecontainer.io')

client.on('connect', () => {
    let i = 1;

    setInterval(() => {
        i++;
        client.publish('test-message', `Hello World: #${i}`);
        console.log(`Sent Message ${i}`);
    }, 1000)
});
```

However when wanting to go higher, I started noticing delays on my computer not being able to handle the amount of subscriptions open... so back to the drawing board!

## Stress Testing - 28k Connections

How can we improve this? Well one simple way is to create a docker container that we can put on a cloud host and simply spin up more instances! So let's do just that and create a Dockerfile + build the image.

**Dockerfile**

```bash
# Note: build with `docker build -t thebillkidy/mqtt-tester:1.0 .`
# Note: push to docker hub with: `docker push thebillkidy/mqtt-test:1.0`
FROM node:latest
WORKDIR /usr/src/app

# Install package.json dependencies
COPY package*.json ./
RUN npm install

# Install app
COPY . .

# Default ENV variables
# Note: specify those while running `docker run -e CLIENT_URL=mqtt://localhost`
ENV CLIENT_CONNECTIONS=1000
ENV CLIENT_URL='mqtt://localhost'

CMD [ "node", "client_massive.js" ]
```

Finishing with building the container and pushing it so that we can use it.

But how can we now deploy this on cloud? Well in Azure we can use the `az cli` to create out containers after being pushed. **So creating a small line we can multiply this * 50!**

```bash
for i in {1..50}; do az container create -g POC-EMQX --name subscriber-$RANDOM --image thebillkidy/mqtt-tester:1.0 --cpu 1 --memory 1 --environment-variables CLIENT_CONNECTIONS=10000 CLIENT_URL=mqtt://xemqx.northeurope.azurecontainer.io --no-wait; echo "Deployed Container $i"; done
```

Allowing a couple of minutes to make sure the containers are being spun up, we can now check the dashboard again. **However!** it seems that it's crashing at around 28k connections...

![./28k.png](./28k.png)

Looking at our statistics of the machine, we see that the memory cap is close to being hit - so let's see if we can work on this.

![./28k-stats.png](./28k-stats.png)

## Stress Testing - 100k Connections

Rather than deploying our `emqx` container with 1GB of RAM and 1 CPU, let's take 4 of both and retry. 

```
# Create container
az container create \
    -g General \
    --name emqx \
    --dns-name-label xemqx \
    --image emqx/emqx:latest \
    --cpu 4 \
    --memory 4 \
    --ports 1883 8883 8083 8084 8080 18083
```

With a script to create 50 x 2k connections

```bash
for i in {1..50}; do az container create -g POC-EMQX --name subscriber-$RANDOM --image thebillkidy/mqtt-tester:1.0 --cpu 1 --memory 1 --environment-variables CLIENT_CONNECTIONS=2000 CLIENT_URL=mqtt://xemqx.northeurope.azurecontainer.io --no-wait; echo "Deployed Container $i"; done
```

Which after a while of waiting to allow the subscriptions to come up shows us!


![./100k.png](./100k.png)
![./100k-stats.png](./100k-stats.png)

So we did it, we scaled it to 100k subscribers!

## Further

So the above is by no means a production system, it's merely a POC showing that we can scale to a certain amount of users. For further research I would like to scale this up towards 1M and even 10M subscribers. To do this, I would need to adapt the tooling written to make sure it scales better (there is a container limit and I can only open 2k subscribers per container in a stable way on this size). Next to that, does it not show how to run this in production and maintain it for a longer amount of time. 

Creating a Pub/Sub system with 100.000 subscribers and 1 publisher


Facebook [decided](https://ai.facebook.com/blog/open-sourcing-reagent-a-platform-for-reasoning-systems/) to release their end-to-end applied reinforcement learning platform called [ReAgent](https://github.com/facebookresearch/ReAgent), after reading their vision on this, I have to say that I am completely hooked! They are providing an excellent view of Reinforcement Learning and the future adoption of it. But why is this and how can we get started with it? 

From working with enterprise customers for the past 2 years, my experience is the following in the Reinforcement Learning domain:
* The customer maturity level is low - they do not know what Reinforcement Learning is, nor do they know how to get started with it
  * To quote one of my customers: "Ah it's that tool used for playing games"
* It's hard to implement in current existing systems, they are mostly based on hard coded rules (or even heuristics if they're modern) making it a technical debt investment
* Modeling the existing problem into a [Markov Decision Process (MDP)](/post/2018/5/20/ai-ml-rl-markov-property-chain-reward-decision) is not always trivial
* Existing systems use a variety of languages: Python, C++, PHP, C#, ... how do you integrate into these applications?
* Personal: I think the performance impact caused by Python should not be overlooked - I for example saw a 44x increase on a personal benchmark I did when comparing C# to Python for an Expected SARSA algorithm.

Which is why I think the ReAgent platform proposal shines! It does solve all the problems mentioned above since it now allows the customer to gradually adapt due to the workflow provided, going from hard-coded rules to eventually Torchscript running the Bandit or RL Models. Illustrated as follows:

![./workflow.jpg](./workflow.jpg)

To get started with this I installed and ran the getting started guide myself.

## Installing ReAgent 

Luckily Getting Started with ReAgent has been made easy due to the [excellent tutorial](http://reagent.ai/rasp_tutorial.html) that is being provided by Facebook. Installing the platform can be done by executing the following:

```bash
# Install extra dependencies
sudo apt-get update
sudo apt-get install build-essential ca-certificates cmake git sudo software-properties-common vim emacs wget
sudo apt-get install unzip
sudo apt-get install libboost-dev # Boost C++ Lib - https://www.boost.org/
sudo apt-get install libgflags-dev # Commandline flags processing - https://github.com/gflags/gflags
sudo apt-get install libgoogle-glog-dev # Application level logging - https://github.com/google/glog
sudo update-ca-certificates

# Install Miniconda
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh
chmod +x miniconda.sh
./miniconda.sh -b # silent install
export PATH="${HOME}/miniconda3/bin:${PATH}" # Enable conda for now, conda init will completely init it in bashrc
#echo 'export PATH="${HOME}/miniconda3/bin:${PATH}"' >> ~/.bashrc
conda config --set auto_activate_base true
conda init
source ~/.bashrc

# Install Spark
wget https://archive.apache.org/dist/spark/spark-2.3.3/spark-2.3.3-bin-hadoop2.7.tgz
tar -xzf spark-2.3.3-bin-hadoop2.7.tgz
sudo mv spark-2.3.3-bin-hadoop2.7 /usr/local/spark
export PATH=$PATH:/usr/local/spark/bin
pip install "gym[classic_control,box2d,atari]"

# Install LibTorch
# see: https://pytorch.org/get-started/locally/
wget https://download.pytorch.org/libtorch/cpu/libtorch-cxx11-abi-shared-with-deps-1.3.0%2Bcpu.zip -O libtorch.zip
unzip libtorch.zip -d $HOME/

# Set JAVA_HOME
export JAVA_HOME="$(dirname $(dirname -- which conda))"
export CONDA_PATH="${HOME}/miniconda"
export LD_LIBRARY_PATH="${CONDA_PATH}/lib:${LD_LIBRARY_PATH}"

# Install ReAgent
conda config --add channels conda-forge
conda config --add channels pytorch
#conda install glog

git clone --recurse-submodules https://github.com/facebookresearch/ReAgent.git

# Install ReAgent
cd ReAgent

conda install --file requirements.txt

mkdir serving/build
cd serving/build
cmake -DCMAKE_PREFIX_PATH=$HOME/libtorch ..
make -j$(nproc)

# Install ephemral package in Python of ReAgent
cd ../../
pip install -e .

# Install spark package
mvn -f preprocessing/pom.xml dependency:resolve
mvn -f preprocessing/pom.xml package
```

## Going from a static decision plan to a contextual bandit

The [**Makin' Bacon** example](http://reagent.ai/rasp_tutorial.html#makin-bacon) provided by the ReAgent documentation is splendid, explaining how we can go from a static pre-configured plan towards a dynamic plan. But what are we actually doing in this example? There are actually 3 phases:

1. Start - We are starting out simple with a 52% bacon chance and 48% ribs chance
    * This through a simple SoftMax ranker
    * We see this by running `heuristic.json` in the simulator, which returns `{'Ribs': 471, 'Bacon': 529}` with an average reward of `0.363`.
2. Hindsight Analysis - No Personalization
    * When we analyze the clicks, we get: `88 390 266 253` for `ribs_clicked, ribs_not_clicked, bacon_clicked, bacon_not_clicked` 
    * This translates into `18%` and `51%` for `ribs` and `bacon` respectively on the click-through rate!
        * Initial Observation here is that we can see that people are more likely to click when they see bacon! (since they aren't rib lovers)
        * We can adapt the decision plan!
    * We will use a `multi-armed bandit` through the `UCB1 bandit ranker`
        * **Note:** Multi-armed bandits will not take into account any state!
        * We now see a score of `0.497` or `{'Bacon': 926, 'Ribs': 74}` - Since we want to show more bacon due to the click-through rate!
3. Smart Analysis - Personalization
    * Our code has been running for a while now and we found an extra parameter that can help this tune for our customers! `isUserARibLover`! If this is `1` then it's a Ribs lover, else it's a Bacon lover.
    * After training this through the dqn workflow, we will see that context is now taken into account and we receive a reward of `0.52` or `{'Bacon': 883, 'Ribs': 117}`

We are now done and understand how the ReAgent framework works. Time to get started ourselves! (that is for a later post though)

Facebook ReAgent - An End-to-End Use Case

An E2E Azure Sphere project in the area of Smart Retail (RFID RC522, AVNet MT3620 SK, Izokee Display)


While working on a blog post where I was utilizing .NET Core I wanted to be able to utilize OpenCV. [OpenCV](https://opencv.org/) is a library of functions that allow us to quickly perform computer vision tasks (e.g. making a picture black and white, canny edge, face recognition, ...). But how do we utilize this in .NET Core?

For the example in this Blog Post, we will work on the use case of **extracting frames from a video file** and saving these individually.

## Installing OpenCV

To install OpenCV, we will utilize a docker container (since most of our applications run there nowadays anyways). The following will take care of :

* Downloading and installing OpenCV
* Downloading and installing OpenCV-Contrib

```bash
FROM microsoft/dotnet:2.1-sdk AS build-env
MAINTAINER Xavier Geerinck <xageerin@microsoft.com>

ENV OPENCV_VERSION="4.1.1"
ENV OPENCV_INSTALLATION_DIR="/opt/opencv/"
ENV OPENCV_SHARP_VERSION="4.1.0.20190417"

WORKDIR /app

# =================================
# Install OpenCV 4 & OpenCV_contrib
# =================================
# Update Packages
RUN sudo apt update
RUN sudo apt -y install build-essential checkinstall cmake pkg-config yasm
RUN sudo apt -y install git gfortran
RUN sudo apt -y install libjpeg8-dev libjpeg-dev libpng-dev
RUN sudo apt -y install libjasper1
RUN sudo apt -y install libtiff-dev
RUN sudo apt -y install libavcodec-dev libavformat-dev libswscale-dev libdc1394-22-dev
RUN sudo apt -y install libxine2-dev libv4l-dev
RUN sudo apt -y install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev
RUN sudo apt -y install libgtk2.0-dev libtbb-dev qt5-default
RUN sudo apt -y install libatlas-base-dev
RUN sudo apt -y install libfaac-dev libmp3lame-dev libtheora-dev
RUN sudo apt -y install libvorbis-dev libxvidcore-dev
RUN sudo apt -y install libopencore-amrnb-dev libopencore-amrwb-dev
RUN sudo apt -y install libavresample-dev
RUN sudo apt -y install x264 v4l-utils
RUN sudo apt -y install libprotobuf-dev protobuf-compiler
RUN sudo apt -y install libgoogle-glog-dev libgflags-dev
RUN sudo apt -y install libgphoto2-dev libeigen3-dev libhdf5-dev doxygen
RUN sudo apt -y install libtbb2 libjasper-dev libdc1394-22-dev

# Download version
RUN cd ${OPENCV_INSTALLATION_DIR}
RUN wget https://github.com/opencv/opencv/archive/${OPENCV_VERSION}.zip -Oopencv-${OPENCV_VERSION}.zip
RUN unzip opencv-${OPENCV_VERSION}.zip
RUN wget https://github.com/opencv/opencv_contrib/archive/${OPENCV_VERSION}.zip -Oopencv_contrib-${OPENCV_VERSION}.zip
RUN unzip opencv_contrib-${OPENCV_VERSION}.zip

# Install OpenCV
RUN cd opencv-${OPENCV_VERSION}
RUN mkdir build && cd build
RUN cmake .. \
	-DCMAKE_BUILD_TYPE=Release \
	-DOPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-4.1.0/modules \
	# you might want to specify other CMake flags through -Dflag=value
RUN sudo make -j$(grep -c ^processor /proc/cpuinfo)
RUN sudo make install -j8
RUN sudo ldconfig

# Copy libs
#RUN cd $OPENCV_INSTALLATION_DIR/lib
#RUN cp -r * /usr/lib
```

## Installing OpenCV Sharp

To utilize OpenCV in .NET we luckily have access to a wrapper library called [OpenCVSharp](https://github.com/shimat/opencvsharp). So we will add this to our Dockerfile to be installed:

```bash
# =================================
# Install OpenCV Sharp
# =================================
RUN cd ${OPENCV_INSTALLATION_DIR}
RUN git clone https://github.com/shimat/opencvsharp.git opencvsharp
RUN cd opencvsharp
RUN git fetch --all --tags --prune && git checkout ${OPENCV_SHARP_VERSION}
RUN cd src
RUN mkdir build
RUN cd build
RUN cmake -D CMAKE_INSTALL_PREFIX=${OPENCV_INSTALLATION_DIR} ..
RUN sudo make -j$(grep -c ^processor /proc/cpuinfo)
RUN sudo make install
RUN sudo ldconfig
RUN sudo cp OpenCvSharpExtern/libOpenCvSharpExtern.so /usr/lib
```

## Creating our project

For our project we will now create a dotnet project, here we will simply take an existing `mp4` file and process it in our code.

```csharp
static void Main(string[] args)
{
	Process("./out.mp4");
}

static void Process(string videoPath)
{
	Console.WriteLine($"[VideoProcessor] Processing videoPath {videoPath}");
	Console.WriteLine("[VideoProcessor] " + (File.Exists(videoPath) ? "Video exists" : "Video does not exist"));

	VideoCapture capture = new VideoCapture(videoPath);

	// using (Window window = new Window("capture"))
	using (Mat image = new Mat()) // Frame image buffer
	{
		var frameIndex = 0;

		// Loop while we can read an image (aka: image.Empty is not true)
		do
		{
			// Read the next
			capture.Read(image);

			// We only want to save every FPS hit since we have 1 image per second -> mod
			if (frameIndex % capture.Fps == 0)
			{
				var saveResult = image.SaveImage($"image_{frameIndex}.png");
				Console.WriteLine($"[VideoProcessor] Saved image #{frameIndex}");
			}

			frameIndex++;
		} while (!image.Empty());
	}

	Console.WriteLine($"[VideoProcessor] Done Processing");
}
```

## Deploying our Project with Docker

To deploy our project, we now need of course to adapt our Dockerfile as well. To do this we will add the following code:

```bash
# =================================
# Install our .NET project
# =================================
COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o out

FROM microsoft/dotnet:2.1-runtime-stretch-slim
WORKDIR /app
COPY --from=build-env /app/out ./

RUN useradd -ms /bin/bash moduleuser
USER moduleuser

ENTRYPOINT ["dotnet", "ModuleFilterCamera.dll"]
```

We are now done and are able to utilize OpenCV in dotnet core!

Utilizing OpenCV in C# .NET Core to grab frames from a video


> This is Part 4 in the IoT Edge series, view the [main article](/iot-edge) or go the [part 3](/iot-edge-part3-simulator-camera) to view the previous article.

![./architecture2.png](./architecture2.png)

## Recap and next steps

We just built our 2 simulators that will produce the data that we want to filter. Before we can create our modules to do this, we will first train an AI model that works on top of this data.

What is this AI model going to do? Well for car data there are a lot of use cases we can have, examples are: location prediction, distance detection, pothole detection, ...

In this case we will go for speed prediction, which has a couple of benefits for us:
1. We can have a regression use case (prediction)
2. We have a real-world example: speed detection can be used to make sure that we are slowing down, or what the adaptation would be for future cycles.
3. We can have real-time data coming in for the future cycles (prediction data) that we can send to cloud to enable future use cases (e.g. stream processing, ...)

Let's get started!

## Initial Setup

### Configuration

For our creation of this module, we will use the following settings:

* **Path:** `/home/xavier/iot-edge`
* **Solution:** EdgeSolutionCarFilter
* **Module Template:** C# Module
* **Module Name:** ModuleFilterCar
* **Docker Repository:** `xavierregistry.azurecr.io/module-filter-car`

## Coding

### Solution Analysis

Remembering our [simulator code](/post/2019/8/10/azure-javascript-iot-iot-edge-part2-simulator-car) for our car data, this was replaying points from a csv and sending them to our device hub. How would this work in a real-world use case? If we think about this, we can define the following steps that should be followed for our IoT Edge device to utilize a nice working AI model:

1. Gather data
2. Train our AI model
3. Deploy our AI model on edge
4. Predict values of our Edge device based on the AI model
5. Repeat

For the sake of simplicity of this article, we will first focus on creating everything manually so that in a later article we can talk about automating all these steps. 

### Step 1. Gathering Data

Since for this article we are sending everything from a CSV file that already contains this gathered data, we can state that step 1. has been finished, so up to step 2!

### Step 2. Training our AI model

We will predict the speed of our car depending on some parameters from the CSV file. Choosing these parameters is critical to have a good working model. In our case we will go for the following as input parameters:

* Throttle Position
* Engine RPM
* Acceleration GS

With our output parameter being:

* Speed MPH

Now how will we train this model? For that we will use [ML.NET](https://dotnet.microsoft.com/apps/machinelearning-ai/ml-dotnet?WT.mc_id=AI-MVP-5004263) which allows us to do this quite easily. Let's get started (for an introduction, feel free to check: [Predicting Instagram with ML.NET](/post/2018/8/24/coding-dotnet-predicting-instagram-with-dotnet-ml))

> **Note:** The reason we are utilizing ML.NET is because it's quite simple to use, plus it allows us to export our model as a `ONNX` format which is the open standard for ML Models.

#### Step 2.1. Creating our ML Project (ML.NET Setup)

We first start by creating a new .NET solution and adding the `Microsoft.ML` dependency to it.

```bash
# Create a new .NET solution
# dotnet new <type> -o <outDir>
dotnet new console -o MLCarFilter

# Add Microsoft.ML as a reference
# dotnet add <solution> package <packageName>
dotnet add MLCarFilter package Microsoft.ML
```

After this is done, we **copy over the `car.csv` file** to our project root. Now we can start writing our prediction code.

#### Step 2.2. Adding our ML code

For our prediction, we can base ourselves on the material from the ML.NET. After searching a bit, I came on the following repository that explains how to utilize a **regression** algorithm in ML.NET (which is what we want to use): [Regression_TaxiFarePrediction](https://github.com/dotnet/machinelearning-samples/tree/master/samples/csharp/getting-started/Regression_TaxiFarePrediction).

Before we start adapting it, first **rename `car.csv` to `car-train.csv`** and **copy some of the lines to a new file called `car-test.csv`**, this file will be our testing data for the regression training. 

> **Note:** We will just be creating a project here to deploy on edge, so we won't go to deep into our ML code. For the full code, feel free to check [GitHub](https://github.com/Xaviergeerinck/PublicProjects/tree/master/C#/IoT)

We can now create the following to create a `Model.zip` in our root folder.

**Program.cs**

```csharp
// USING statements 
namespace MLCarFilter
{
    class Program
    {
        private static string trainingFilePath = "./car-train.csv";
        private static string testFilePath = "./car-test.csv";
        private static string modelOutputPath = "./Model.zip";

        static void Main(string[] args)
        {
            TrainModel();
            TestModel();
        }

        public static void TrainModel()
        {
            // Create ML Context with seed for repeteable/deterministic results
            MLContext mlContext = new MLContext(seed: 0);

            // STEP 1: Common data loading configuration
            IDataView trainingDataView = mlContext.Data.LoadFromTextFile<CarPoint>(trainingFilePath, hasHeader: true, separatorChar: ',');
            IDataView testDataView = mlContext.Data.LoadFromTextFile<CarPoint>(testFilePath, hasHeader: true, separatorChar: ',');

            // STEP 2: Common data process configuration with pipeline data transformations
            var dataProcessPipeline = mlContext.Transforms.CopyColumns(outputColumnName: "Label", inputColumnName: nameof(CarPoint.Speed_MPH))
                .Append(mlContext.Transforms.NormalizeMeanVariance(outputColumnName: "ThrottlePosition_Normalized", inputColumnName: nameof(CarPoint.ThrottlePosition)))
                .Append(mlContext.Transforms.NormalizeMeanVariance(outputColumnName: "Engine_RPM_Normalized", inputColumnName: nameof(CarPoint.Engine_RPM)))
                .Append(mlContext.Transforms.NormalizeMeanVariance(outputColumnName: "Acceleration_Gs_Normalized", inputColumnName: nameof(CarPoint.Acceleration_Gs)))
                .Append(mlContext.Transforms.Concatenate("Features", "ThrottlePosition_Normalized", "Engine_RPM_Normalized", "Acceleration_Gs_Normalized"));

            Console.WriteLine("================= Labels & Features ==================");
            Console.WriteLine($"Label:\n\t{nameof(CarPoint.Speed_MPH)}");
            Console.WriteLine($"Features: \n\t[V1] {nameof(CarPoint.ThrottlePosition)} \n\t[V2] {nameof(CarPoint.Engine_RPM)} \n\t[V3] {nameof(CarPoint.Acceleration_Gs)}");

            // STEP 3: Set the training algorithm, then create and config the modelBuilder - Selected Trainer (SDCA Regression algorithm)                            
            var trainer = mlContext.Regression.Trainers.Sdca(labelColumnName: "Label", featureColumnName: "Features");
            var trainingPipeline = dataProcessPipeline.Append(trainer);

            // STEP 4: Train the model fitting to the DataSet
            //The pipeline is trained on the dataset that has been loaded and transformed.
            Console.WriteLine("================= Training the model =================");
            var trainedModel = trainingPipeline.Fit(trainingDataView);

            // STEP 5: Evaluate the model and show accuracy stats
            Console.WriteLine("===== Evaluating Model's accuracy with Test data =====");

            IDataView predictions = trainedModel.Transform(testDataView);
            var metrics = mlContext.Regression.Evaluate(predictions, labelColumnName: "Label", scoreColumnName: "Score");

            // Common.ConsoleHelper.PrintRegressionMetrics(trainer.ToString(), metrics);

            // STEP 6: Save/persist the trained model to a .ZIP file
            mlContext.Model.Save(trainedModel, trainingDataView.Schema, modelOutputPath);

            Console.WriteLine("======================================================");
            Console.WriteLine("The model is saved to {0}", modelOutputPath);
        }

        public static void TestModel() 
        {
            // Create ML Context with seed for repeteable/deterministic results
            MLContext mlContext = new MLContext(seed: 0);

            // Common.ConsoleHelper.PrintRegressionMetrics(trainer.ToString(), metrics);

            var carPointSample = new CarPoint()
            {
                Time = "2018-04-08 10:32:55.390684",
                Seconds = 772.693372F,
                Latitude_Y_Degrees = 30.321299F,
                Longitude_X_Degrees = -97.75582299999999F,
                Distance_Miles = 7.96F,
                Speed_MPH = 30.647F,
                SteeringAngle = -0.9F,
                ThrottlePosition = 2F,
                Engine_RPM = 1624F,
                Lateral_Gs = -0.01F,
                Acceleration_Gs = -0.05F
            };

            ITransformer trainedModel;
            using (var stream = new FileStream(modelOutputPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                trainedModel = mlContext.Model.Load(stream, out var modelInputSchema);
            }

            // Create prediction engine related to the loaded trained model
            var predEngine = mlContext.Model.CreatePredictionEngine<CarPoint, CarPointSpeedPrediction>(trainedModel);

            //Score
            var resultprediction = predEngine.Predict(carPointSample);

            Console.WriteLine("======================================================");
            Console.WriteLine($"Predicted speed: {resultprediction.Speed_MPH:0.####}, actual speed: 30.647");
            Console.WriteLine("======================================================");
        }
    }
}
```

### Step 3. Deploying our AI model on Edge

Once our `Model.zip` was created, we can now put that on our Edge module. In our case we will do this by **manual** inclusion for this blog post, so just copy it over to the `EdgeSolutionCarFilter` project into the `ModuleFilterCar/model/` folder.

**Important!**

To make sure that this model gets copied to our output directory, we have to adapt our `.csproj` file to do this. For this add the following piece of code:

```xml
<ItemGroup>
    <ProjectCapability Include="AzureIoTEdgeModule"/>
    <Content Include="model\**">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
</ItemGroup>
```

### Step 4. Predicting values of our Edge Device based on the deployed AI model

The final step is to incorporate the usage of our trained model in the Edge module. To do this, we will first add `Microsoft.ML` to the dependencies of the .NET project with `dotnet add ModuleFilterCar package Microsoft.ML` and add the following code for `Program.cs`, which will utilize the model that we just built and send the predictions to IoT Hub.

**ModuleCarSimulator/Program.cs**

Change the `SendEventAsync` call to `ioTHubModuleClient.SendEventAsync("input-simulator-car", message);`

**Program.cs**

In our `Init()` method, we will first make sure that we can process values that were received from the `EdgeHub`, so change the following line:

```csharp
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
```

Towards:

```csharp
await ioTHubModuleClient.SetInputMessageHandlerAsync("input-simulator-car", ProcessSimulatorCarMessages, ioTHubModuleClient);
```

> **Note:** We can test this `input-simulator-car` by the following curl request: `curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input-simulator-car","data":"2018-04-08 10:31:56.690670,713.9933580000001,30.32343,-97.756062,7.75,35.313,-7.6,2,1861,0.05,-0.16"}' http://localhost:53000/api/v1/messages`

Now add a method called `ProcessSimulatorCarMessages` as a `Task` type as follows:

```csharp
/// <summary>
/// This method is called whenever the module is sent a message from the EdgeHub. 
/// It just pipe the messages without any change.
/// It prints all the incoming messages.
/// </summary>
static async Task<MessageResponse> ProcessSimulatorCarMessages(Message message, object userContext)
{
    int counterValue = Interlocked.Increment(ref counter);

    var moduleClient = userContext as ModuleClient;
    if (moduleClient == null)
    {
        throw new InvalidOperationException("UserContext doesn't contain " + "expected values");
    }

    byte[] messageBytes = message.GetBytes();
    string messageString = Encoding.UTF8.GetString(messageBytes);
    Console.WriteLine($"[Message #{counterValue}] {messageString}");

    // If our message is not empty, parse it and send back the prediction to IoT Hub.
    if (!string.IsNullOrEmpty(messageString))
    {
        // Predict the speed
        var splittedMessage = messageString.Split(",");
        var predictedCarSpeed = PredictValue(float.Parse(splittedMessage[7]), float.Parse(splittedMessage[8]), float.Parse(splittedMessage[10]));
        var messageResult = new Message(Encoding.UTF8.GetBytes("" + predictedCarSpeed));

        // Print on Console
        var now = DateTime.Now.ToString("g");
        System.Console.WriteLine($"[Simulator][{now}] Sending Prediction: {predictedCarSpeed}, Actual Speed: {splittedMessage[5]}");

        // Send to IoT Hub
        await moduleClient.SendEventAsync("output-filter-car", messageResult);
    }

    return MessageResponse.Completed;
}
```

That will use the `PredictValue` method: 

```csharp
public static float PredictValue(float ThrottlePosition, float Engine_RPM, float Acceleration_GS) 
{
    // Create ML Context with seed for repeteable/deterministic results
    MLContext mlContext = new MLContext(seed: 0);

    var carPointSample = new CarPoint()
    {
        ThrottlePosition = ThrottlePosition,
        Engine_RPM = Engine_RPM,
        Acceleration_Gs = Acceleration_GS
    };

    ITransformer trainedModel;
    using (var stream = new FileStream(modelOutputPath, FileMode.Open, FileAccess.Read, FileShare.Read))
    {
        trainedModel = mlContext.Model.Load(stream, out var modelInputSchema);
    }

    // Create prediction engine related to the loaded trained model
    var predEngine = mlContext.Model.CreatePredictionEngine<CarPoint, CarPointSpeedPrediction>(trainedModel);

    // Score
    var resultprediction = predEngine.Predict(carPointSample);

    return resultprediction.Speed_MPH;
}
```

### Step 5. Hooking our Simulator to the Filter Module

A last thing we will do is to create our deployment with our `deployment.template.json` file. Here we will however **connect the simulator to the filter and the filter to our cloud**. We do this like this:

```json
"$edgeHub": {
    "properties.desired": {
    "schemaVersion": "1.0",
    "routes": {
        "ModuleSimulatorCarToIoTHub": "FROM /messages/modules/ModuleSimulatorCar/outputs/output-simulator-car INTO BrokeredEndpoint(\"/modules/ModuleFilterCar/inputs/input-simulator-car\")",
        "ModuleFilterCarToIoTHub": "FROM /messages/modules/ModuleFilterCar/outputs/* INTO $upstream"
    },
    "storeAndForwardConfiguration": {
        "timeToLiveSecs": 7200
    }
    }
}
```

Now everything should be working once you deploy, and you will see the following:

```bash
IoT Hub module client initialized.
[Filter][08/23/2019 16:21][Message #1] 2018-04-08 10:32:17.919074,735.221761,30.322184999999998,-97.75674599999999,7.85,29.375,2.2,14,1774,-0.03,0.02
[Filter][08/23/2019 16:21] Sending Prediction: 33.95982, Actual Speed: 29.375
[Filter][08/23/2019 16:21][Message #2] 2018-04-08 10:32:17.990676,735.293363,30.322177000000003,-97.756744,7.86,29.42,2.0,13,1748,-0.02,0.02
[Filter][08/23/2019 16:21] Sending Prediction: 33.32725, Actual Speed: 29.42
```

within our IoT Hub overview on the device, the following modules activated:

![./iot-edge-modules-car-filter.png](./iot-edge-modules-car-filter.png)

## Conclusion

We just created our filter method with a few simple steps that created a small .NET application that utilized ML.NET to train our AI model. Further steps would now be to create an automated pipeline that does this on top of batch data and updates the AI model on edge with it (by creating a deployment at scale). This however is not in the scope of this series but might be something I cover later on.

Part 4 - Creating a Automated Machine Learning model based on our Car Simulation Data


So far I have been using Travis-CI as my Continuous Integration (CI) system for my build and release process for my Blog. However recently, VSTS got rebranded to Azure Pipelines, and I felt everything got mature enough to finally migrate to Azure Pipelines. To my surprise this turned out to be super easy! Let's see how it can be done!

What do we want to achieve? Well we want to achieve a continuous flow of development, where when we develop a piece of code, the following steps are followed (as illustrated below):

1. **SCM:** Use our SCM protocol to push our code
2. **PULL CODE:** Our source control repository, triggers an event 
3. **BUILD:** This trigger gets detected by our Pipeline process which builds our code
4. **TEST:** The Build gets tested
5. **FAIL/SUCCESS:** This results in a failure or success
6. **RELEASE:** On success we release our code to the world

![./ci-pipeline.png](./ci-pipeline.png)

## Pipeline Definition

Translating this continuous flow of development to our own project, what we want to do is that as soon as a commit is pushed on to the `development` branch (which contains our `.md` blog files), we want to trigger a build that is going to transform these to `.html` files and push those onto the `master` branch. Writing this out in steps would look like:

1. Trigger: On push to `development` branch
2. Setup our git repository
3. Build our Jekyll site to `/tmp` through `jekyll build -d /tmp`
4. Copy over everything from `/tmp` to our working folder (replacing everything except the `.git/` folder)
5. Create a commit and push it to remote

## Pipeline Coding

To code this actual pipeline utilizing `Azure DevOps`, we can utilize a `azure-pipelines.yml` file that we place in the root of our repository. We can now describe what should happens using the `steps:` in this files, let's do this in phases:

### Step 1: Trigger on-push to Development Branch

Describing to trigger on push is just 2 lines of code:

```yaml
trigger:
- development
```

### Step 2: Set pool & global variables 

Since GitHub wants us to utilize a PAT token to be able to trigger a page build, we will need to add this to our environment variables (as a secret! - see [https://docs.microsoft.com/en-us/azure/devops/pipelines/process/variables](https://docs.microsoft.com/en-us/azure/devops/pipelines/process/variables?WT.mc_id=DOP-MVP-5004263&view=azure-devops&tabs=yaml%2Cbatch#secret-variables) for more information).

We can also define a pool (execution environment) that our code will run on.

```yaml
pool:
  vmImage: 'Ubuntu-16.04'

# Note: github_pat should be configured as an environment variable in devops
#   -> create github pat here: https://github.com/settings/tokens
#   -> Create environment variable in dev.azure.com under pipelines -> edit (right top) -> variables (right top triple dots) -> called github_pat -> click the lock
variables:
  gh_user: thebillkidy
  gh_repo: thebillkidy.github.io
  gh_pass: $(github_pat)
  gh_email: xavier.geerinck@gmail.com
  gh_auth_header: $(echo -n "${gh_user}:$(github_pat)" | base64);
```

### Step 3: Pull our Code

Since we set up the PAT token and other variables, we can now start cloning our directory. Let's define the steps for this

> **Note:** We clone our directory rather than using the `checkout` function due to the PAT token being required for a page build (see previous step).

```yaml
steps:
# https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=azdevops&tabs=schema#checkout
- checkout: none # we are not going to sync sources, we will manually clone
  persistCredentials: false # We disallow setting the persisting, since we want to have a verified push which requires a PAT token

# 1. Setup our local repository and branch that we can work on
- script: git clone https://$(github_pat)@github.com/$(gh_user)/$(gh_repo).git .
  workingDirectory: $(Build.StagingDirectory)
  displayName: "[Git] Clone GitHub Pages Repository"

- script: |
    git config user.email $(gh_email)
    git config user.name $(gh_user)
  workingDirectory: $(Build.StagingDirectory)
  displayName: '[Git] Configure User'

- script: 'git checkout development'
  workingDirectory: $(Build.StagingDirectory)
  displayName: '[Git] Set development branch'
```

### Step 4: Build our Jekyll Website

We can now build our Jekyll website, to do this we will utilize a `/tmp/source` and `/tmp/build` directory to be able to generate clean `.html` diffs in our commit messages on master. 

```yaml
# 2. Configure Ruby
- task: UseRubyVersion@0 # See: https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/tool/use-ruby-version?view=azdevops
  displayName: '[Ruby] Use Ruby >= 2.5'

# 3. Build Site - We only want a HTML diff on master, so we follow this process
#      1. Copy files from development branch to /tmp/source
#      2. Build Jekyll on /tmp/source to /tmp/build
#      3. Remove all files in $(Build.StagingDirectory) except .git/
#      4. Copy everything from /tmp/build to $(Build.StagingDirectory)/
#      5. Create the commit and push it
- script: 'git checkout development'
  workingDirectory: $(Build.StagingDirectory)
  displayName: '[Git] Switch to development branch for $(Build.StagingDirectory)'

- script: 'mkdir /tmp/source; cp -R * /tmp/source; rm -rf /tmp/source/.git'
  workingDirectory: $(Build.StagingDirectory)
  displayName: '[Script] Copy file from development branch to /tmp/source'

- script: 'git checkout master'
  workingDirectory: $(Build.StagingDirectory)
  displayName: '[Git] Switch to master branch for $(Build.StagingDirectory)'

- script: 'gem install bundler'
  workingDirectory: /tmp/source
  displayName: '[Jekyll] Install Bundler'

- script: |
    ls -la;
    bundle install
  workingDirectory: /tmp/source
  displayName: '[Jekyll] Install Jekyll and Dependencies'

- script: |
    mkdir /tmp/build;
    bundle exec jekyll build -d /tmp/build;
  workingDirectory: /tmp/source
  displayName: '[Jekyll] Build Jekyll Static Site from /tmp/source to /tmp/build'

- script: |
    cp -R $(Build.StagingDirectory)/.git /tmp/build;
    rm -rf $(Build.StagingDirectory)/*;
    cp -R /tmp/build/* $(Build.StagingDirectory);
  workingDirectory: /tmp/build
  displayName: '[Script] Remove all files in $(Build.StagingDirectory) except .git/ and add files from /tmp/build'
```

### Step 5: Push our changes

Last but not least is the easiest part, pushing it all to master:

```yaml
# 3. Create our commit, merge into master, delete draft branch and push it
- script: |
    git add --all;
    git commit -m"Pipelines-Bot: Updated site via $(Build.SourceVersion)";
  workingDirectory: $(Build.StagingDirectory)
  displayName: '[Git] Creating commit'

- script: |
    git push origin master;
  workingDirectory: $(Build.StagingDirectory)
  displayName: '[Git] Push changes to remote'
```

### Step 6: Checking Pages Build 

As an extra, we would like to utilize the PAT token to check our pages build and see if it was successful. For that we can utilize the following in our pipeline:

```yaml
- script: |
    curl https://api.github.com/repos/$(gh_user)/$(gh_repo)/pages/builds/latest -i -v \
    -X GET \
    -H "Accept: application/vnd.github.mister-fantastic-preview+json" \
    -H "Authorization: Basic $(gh_auth_header)"
  displayName: '[GitHub] Get Page Build Status'
```

## Conclusion

When comparing my new Azure DevOps Pipelines to the old Travis Job, I am able to say that Azure DevOps Pipelines allows me to more fine grained configure my tasks as well as deploy, really showing how strong this product is for the enterprise market.

Another noticeable thing is the performance. When deploying with Travis, my builds often took between 2 - 3 minutes, while with Azure DevOps Pipelines this takes around 1m 40s

If you're interested in the full source code, feel free to check this at: [https://github.com/Xaviergeerinck/thebillkidy.github.io/blob/development/azure-pipelines.yml](https://github.com/Xaviergeerinck/thebillkidy.github.io/blob/development/azure-pipelines.yml) which is this code being used for my own personal blog ;)

Build your Jekyll site and Deploy it on GitHub Pages with an Azure DevOps pipeline


> This is Part 3 in the Iot Edge series, view the [main article](/post/2019/8/10/azure-javascript-iot-iot-edge) or go the [part 2](/post/2019/8/10/azure-javascript-iot-iot-edge-part2-simulator-car) to view the previous article.

![./architecture2.png](./architecture2.png)

## Recap and next steps

In [part 2](/post/2019/8/10/azure-javascript-iot-iot-edge-part2-simulator-car) we created our car data simulator that will send data points every second from a CSV file. Next up is a second simulator that will create a video as a camera would do and save it on disk, so that a processor can use it.

> Unique here is that we will be utilizing this to create a video stream that is utilizing a shared folder through **Azure IoT Edge createOptions**

## Initial Setup

Our Video simulator will utilize some of the code from the previous simulator. However since we are using video frames here, we should not send them straight to cloud, nor should we use MQTT to send them to our device hub. A more efficient way is that we create a video from these frames (as a camera would do, but rather than creating a video it would then stream to a `/dev/` interface) and save this video to a shared path that another module can read.

Remember: our edge device has it's own hub, and runs modules (containers). We can thus use the underlying OS running our modules as a "share" and mount a shared path (e.g. /tmp) to these modules. If our module A would then write to this mount, module B would be able access it as well.

### Configuration

For our creation of this module, we will use the following settings:

* **Path:** `/home/xavier/iot-edge`
* **Solution:** EdgeSolutionCameraFilter
* **Module Template:** C# Module
* **Module Name:** ModuleSimulatorCamera
* **Docker Repository:** `xavierregistry.azurecr.io/module-simulator-camera`

### Data Gathering

For the data that will be used for the video we will - as mentioned before - again utilize the data from [https://github.com/cloudpose/smartphone_driving_dataset](https://github.com/cloudpose/smartphone_driving_dataset). This provides us a dataset of 3,419 images. Now for simplicity reasons we will only get a couple of frames (~10Mb) in our data folder (as in the previous simulator). I chose the following frames: 

* output_141.png
* output_197.png
* output_340.png
* output_384.png
* output_2535.png -> output_2560.png

> **FYI:** I use a remote development PC, so to copy these files specifically I had to copy them to a SSH terminal. To do this I used: `scp *.png xavier@<SERVER_IP>:/home/xavier/iot-edge/EdgeSolutionCameraFilter/modules/ModuleSimulatorCamera/data`

## Coding our Simulator

### Configuring the deployment template + Dockerfile for our stream path

Our code is mostly a copy paste of the previous code. The only thing that will change here is that we will have to send the images to the next module.

> **Important:** As mentiond in our Initial Setup, we should **NOT** use MQTT to send all these messages to cloud. Rather than that we should utilize a mount to provide a path that we can write our video to.

To access our shared path from the OS (`/tmp`) in our module under `/app/stream` we will have to specify this in our module's deployment file `deployment.template.json`. Luckily a key called `createOptions` exists that allows us to do this (see [https://docs.microsoft.com/en-us/azure/iot-edge/module-edgeagent-edgehub](https://docs.microsoft.com/en-us/azure/iot-edge/module-edgeagent-edgehub?WT.mc_id=IoT-MVP-5004263#edgeagent-desired-properties) for more information).

This will look like this to mount the `/tmp` folder to our `/app/stream` path:

```json
"modules": {
  "ModuleSimulatorCamera": {
    "version": "1.0",
    "type": "docker",
    "status": "running",
    "restartPolicy": "always",
    "settings": {
      "image": "${MODULES.ModuleSimulatorCamera}",
      "createOptions": {
        "HostConfig": {
          "Mounts": {
            "Target": "/app/stream/",
            "Source": "/tmp"
          }
        }
      }
    }
  }
}
```

Next we will adapt our Dockerfile.amd64 (and Dockerfile.arm32v7) to add the following above the `ENTRYPOINT` statement, as well as add the dependency on ffmpeg:

```bash
# Add streaming directory
RUN mkdir -p /app/stream

# Install ffmpeg
RUN sudo apt-get install ffmpeg
```

### Program.cs

Our `Program.cs` is quite trivial, since we will let `ffmpeg` handle the difficult part of merging our frames from the `data/` folder into a video file. Putting this into the same kind of framework as we did in our first simulator, makes us ending up with:

```csharp
static string videoDestinationPath = "/app/stream/out.mp4";

// ...

static async Task Init()
{
    MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
    ITransportSettings[] settings = { mqttSetting };

    // Open a connection to the Edge runtime
    ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
    await ioTHubModuleClient.OpenAsync();
    Console.WriteLine("IoT Hub module client initialized.");

    // Start our simulator
    // Note: this is not async, we can run on the main thread
    StartSimulator(ioTHubModuleClient, "data/");
}

static void StartSimulator(ModuleClient ioTHubModuleClient, string filePath)
{
    // Get the images that we want to convert to a video stream
    string [] fileEntries = Directory.GetFiles(filePath);

    var process = new Process()
    {
        StartInfo = new ProcessStartInfo
        {
            FileName = "ffmpeg",
            Arguments = $"-y -framerate 1 -pattern_type glob -i {filePath}/*.png -c:v libx264 -r 30 -pix_fmt yuv420p -vf \"pad=ceil(iw/2)*2:ceil(ih/2)*2\" {videoDestinationPath}",
            UseShellExecute = false,
            CreateNoWindow = true,
        }
    };

    // Compile the video
    // Console.WriteLine($"ffmpeg -y -framerate 1 -pattern_type glob -i {Directory.GetCurrentDirectory()}/{filePath}*.png -c:v libx264 -r 30 -pix_fmt yuv420p -vf \"pad=ceil(iw/2)*2:ceil(ih/2)*2\" {videoDestinationPath}");
    Console.WriteLine($"[Simulator][{DateTime.Now.ToString("g")}] Creating video file from images in {filePath}*.png");   
    process.Start();
    process.WaitForExit();
    Console.WriteLine($"[Simulator][{DateTime.Now.ToString("g")}] Wrote video file to {videoDestinationPath}");

    // Wait a minute before we repeat
    Console.WriteLine($"[Simulator][{DateTime.Now.ToString("g")}] Waiting 60 seconds before repeating");
    System.Threading.Thread.Sleep(60 * 1000);
    StartSimulator(ioTHubModuleClient, filePath);
}
```

We can see that we will just create our process in C# and wait till it finishes. Once it finishes we will wait 60 seconds before redoing this complete process.

> **Note:** We wait one minute for this simulator, since we could for example make the `data/` folder receive frames from a mount as well, potentially allowing for a dynamic recompilation process.

### Deploying our Simulator

Just as before, we can now deploy our simulator:

1. Login to our container repository: `sudo docker login -u <USERNAME> -p <PASSWORD> <LOGIN_SERVER>`
2. Right click on `deployment.template.json` and: `Build and Push IoT Edge Solution` which will initiate a `docker build  --rm -f "/home/xavier/iot-edge/EdgeSolutionCameraFilter/modules/ModuleSimulatorCamera/Dockerfile.amd64" -t xavierregistry.azurecr.io/module-simulator-camera:0.0.1-amd64 "/home/xavier/iot-edge/EdgeSolutionCameraFilter/modules/ModuleSimulatorCamera" && docker push xavierregistry.azurecr.io/module-simulator-camera:0.0.1-amd64` command.
3. Right click on our device in the Azure IoT Hub Extension and click `Create Deployment for Single Device` and navigate to the path of our solution config deployment. E.g. `/EdgeSolutionCameraFilter/config/deployment.amd64.json`

Congratulations, our Camera Simulator is now finished! Let's get started on our [Machine Learning Model!](/post/2019/8/23/azure-javascript-iot-iot-edge-part4-ml-car)

Part 3 - Creating a Car Camera simulator in IoT Edge


> This is Part 2 in the Iot Edge series, view the [main article](/post/2019/8/10/azure-javascript-iot-iot-edge) or go the [part 1](/post/2019/8/10/azure-javascript-iot-iot-edge-part1) to view the previous article.

![./architecture2.png](./architecture2.png)

## Recap and next steps

In [part 1](/post/2019/8/10/azure-javascript-iot-iot-edge-part1) we created our cloud infrastructure, our initial device connected to it and afterwards wrote a simulator module that we pushed to the edge device, that will send us the time every 30 seconds 

What we want to do now is that we want to create 2 solutions as shown in our architecture that will simulate car data and video data. So let's get started!

## Initial Setup

### Configuration

As we learned in [part 1](/post/2019/8/10/azure-javascript-iot-iot-edge-part1) we set up a new IoT Edge solution with the following parameters:

* **Path:** `/home/xavier/iot-edge`
* **Solution:** EdgeSolutionCarFilter
* **Module Template:** C# Module
* **Module Name:** ModuleSimulatorCar
* **Docker Repository:** `xavierregistry.azurecr.io/module-simulator-car`

### Data Gathering

We start off with finding a dataset of points that we want our simulator to use. We will then send off each of these datapoints every second as our simulation.

> **Note:** In real-life you would not use a simulator but just use a module to capture your Video Feed/CAN Dongle/USB/... connected to the device

Luckily an excellent repository exist on GitHub that contains an interesting dataset for car datapoints that are comparable to a CAN bus: [https://github.com/cloudpose/smartphone_driving_dataset](https://github.com/cloudpose/smartphone_driving_dataset) 

This dataset (`dataset_car.csv`) has the following fields:

* Time
* Seconds
* Latitude / Y Position (Degrees)
* Longitude / X Position (Degrees)
* Distance (Miles)
* Speed (MPH)
* Steering Angle
* Throttle Position
* Engine RPM
* Lateral Gs
* Acceleration Gs

## Coding our Simulator

### Program.cs

Start off by creating a new file called `car.csv` in a new `data` folder under your module (this is where `Program.cs` is located - e.g. `EdgeSolutionCarFilter/modules/ModuleSimulatorCar/data/car.csv`)

Once this is done, adapt your `Program.cs` file to look like this for the `Init()`:

```csharp
static async Task Init()
{
    MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
    ITransportSettings[] settings = { mqttSetting };

    // Open a connection to the Edge runtime
    ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
    await ioTHubModuleClient.OpenAsync();
    Console.WriteLine("IoT Hub module client initialized.");

    // Start our simulator
    // Note: this is not async, we can run on the main thread
    StartSimulator(ioTHubModuleClient, "data/car.csv");
}
```

The above will open our `IoT Edge Hub` connection through the `MQTT` transport layer, whereafter we start our simulator.

> Note: This opens a connection to the `IoT Edge Hub`! Which is still locally running and not to cloud. It's this Hub that will act as our kind of service bus and send the events to `IoT Hub` on Azure.

With the Simulator code looking like:

```csharp
static void StartSimulator(ModuleClient ioTHubModuleClient, string filePath)
{
    int lineCount = 0;
    string line;

    System.IO.StreamReader file = new System.IO.StreamReader(filePath);

    while ((line = file.ReadLine()) != null)
    {
        // Skip the first line -> it's the header
        if (lineCount == 0) {
            lineCount++;
            continue;
        }

        // Send message
        var now = DateTime.Now.ToString("g");
        System.Console.WriteLine($"[Simulator][{now}] {line}");
        var message = new Message(Encoding.UTF8.GetBytes(line));
        ioTHubModuleClient.SendEventAsync("output", message);

        // Sleep for a second and go to the next line
        lineCount++;
        System.Threading.Thread.Sleep(1000);
    }

    file.Close();

    // Loop infinitely
    System.Console.WriteLine("[Simulator] Reached end of CSV file, restarting");
    StartSimulator(ioTHubModuleClient, filePath);
}
```

This is a quite trivial simulator, just reading our CSV line by line and sending the lines to the IoT Edge Device Hub on the "output" channel. See the following link for the method doing this: [https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.devices.client.moduleclient.sendeventasync?view=azure-dotnet](https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.devices.client.moduleclient.sendeventasync?view=azure-dotnet&WT.mc_id=IoT-MVP-5004263#Microsoft_Azure_Devices_Client_ModuleClient_SendEventAsync_System_String_Microsoft_Azure_Devices_Client_Message_)

When now testing this module, we see:

```bash
xavier@PersonalVM:~/iot-edge/EdgeSolutionCarFilter/modules/ModuleSimulatorCar$ env $(sudo iotedgehubdev modulecred | xargs) dotnet run
IoT Hub module client initialized.
[Simulator][8/10/19 10:46 AM] 2018-04-08 10:31:37.005628,694.308316,30.327355999999998,-97.75596800000001,7.47,61.563,-0.3,13,2146,-0.0,-0.02
[Simulator][8/10/19 10:46 AM] 2018-04-08 10:31:37.090666,694.393353,30.327336,-97.755969,7.47,61.51,-0.3,13,2145,-0.0,-0.02
[Simulator][8/10/19 10:46 AM] 2018-04-08 10:31:37.190665,694.4933530000001,30.327312,-97.755969,7.48,61.448,-0.3,13,2144,-0.0,-0.02
[Simulator][8/10/19 10:46 AM] 2018-04-08 10:31:37.247328,694.550016,30.327298,-97.755969,7.48,61.412,-0.3,13,2144,-0.0,-0.02
```

### Deploying our Simulator

So we can deploy this to our container registry as learned in the [first part](/post/2019/8/10/azure-javascript-iot-iot-edge-part1) with the following `deployment.template.json` file:

```json
{
  "$schema-template": "1.0.0",
  "modulesContent": {
    "$edgeAgent": {
      "properties.desired": {
        "schemaVersion": "1.0",
        "runtime": {
          "type": "docker",
          "settings": {
            "minDockerVersion": "v1.25",
            "loggingOptions": "",
            "registryCredentials": {
              "xavierregistry": {
                "username": "$CONTAINER_REGISTRY_USERNAME_xavierregistry",
                "password": "$CONTAINER_REGISTRY_PASSWORD_xavierregistry",
                "address": "xavierregistry.azurecr.io"
              }
            }
          }
        },
        "systemModules": {
          "edgeAgent": {
            "type": "docker",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-agent:1.0",
              "createOptions": {}
            }
          },
          "edgeHub": {
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-hub:1.0",
              "createOptions": {
                "HostConfig": {
                  "PortBindings": {
                    "5671/tcp": [
                      {
                        "HostPort": "5671"
                      }
                    ],
                    "8883/tcp": [
                      {
                        "HostPort": "8883"
                      }
                    ],
                    "443/tcp": [
                      {
                        "HostPort": "443"
                      }
                    ]
                  }
                }
              }
            }
          }
        },
        "modules": {
          "ModuleSimulatorCar": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "${MODULES.ModuleSimulatorCar}",
              "createOptions": {}
            }
          }
        }
      }
    },
    "$edgeHub": {
      "properties.desired": {
        "schemaVersion": "1.0",
        "routes": {
          "ModuleSimulatorCarToIoTHub": "FROM /messages/modules/ModuleSimulatorCar/outputs/* INTO $upstream"
        },
        "storeAndForwardConfiguration": {
          "timeToLiveSecs": 7200
        }
      }
    }
  }
}
```

Now we can:

> **Note:** Make sure that you set the configuration in your `.env` file for the container registry (see `registryCredentials` in  `deployment.amd64.json` for the required keys)

1. Login to our container repository: `sudo docker login -u <USERNAME> -p <PASSWORD> <LOGIN_SERVER>`
2. Right click on `deployment.template.json` and: `Build and Push IoT Edge Solution` which will initiate a `docker build  --rm -f "/home/xavier/iot-edge/EdgeSolutionCarFilter/modules/ModuleSimulatorCar/Dockerfile.amd64" -t xavierregistry.azurecr.io/module-simulator-car:0.0.1-amd64 "/home/xavier/iot-edge/EdgeSolutionCarFilter/modules/ModuleSimulatorCar" && docker push xavierregistry.azurecr.io/module-simulator-car:0.0.1-amd64` command.
3. Right click on our device in the Azure IoT Hub Extension and click `Create Deployment for Single Device` and navigate to the path of our solution config deployment. E.g. `/EdgeSolutionCarFilter/config/deployment.amd64.json`

When all of this is done, when we now open a demo reader for IoT Hub (see [My PublicProjects](https://github.com/Xaviergeerinck/PublicProjects/tree/master/JS/Azure/EventHub/Receiver) for an example) we see:

```bash
[IoTHubMonitor] Start monitoring message arrived in built-in endpoint for device [xavier-device-1] ...
[IoTHubMonitor] Created partition receiver [0] for consumerGroup [$Default]
[IoTHubMonitor] Created partition receiver [1] for consumerGroup [$Default]
[IoTHubMonitor] [11:40:29 AM] Message received from [xavier-device-1/ModuleSimulatorCar]:
"2018-04-08 10:31:38.515609,695.818296,30.326990000000002,-97.755974,7.5,60.625,-0.4,0,2119,-0.01,-0.04"
```

> **Note:** In case you don't see this, you should go and debug the solution. A good starting point here is to logon on your device and check the `docker logs` of the `edgeAgent` through `sudo docker logs edgeAgent`.

Congratulations, our Car Simulator is now finished!, you can now go to [Part 3: Building the simulator for the Camera](/post/2019/8/10/azure-javascript-iot-iot-edge-part3-simulator-camera)


Part 2 - Creating a Car Data simulator in IoT Edge


> This is Part 1 in the Iot Edge series, view the [main article](/post/2019/8/10/azure-javascript-iot-iot-edge).

![./architecture2.png](./architecture2.png)

Looking at our architecture, we need to be able to connect out devices and get some interesting output from them before we can actually do something with them. In this first part we will be mainly focusing on doing just that - connecting our devices and sending data to our IoT Hub resource.

Therefor in this Part we have the following **prerequisities:**

> Note for my variables I used the following:
> * YOUR_IOTHUB_NAME = xavier-iothub
> * YOUR_DEVICE_ID = xavier-device-1
> * YOUR_EDGE_VM = xavier-edge-1

## Prerequisites

* IoT Hub - Connect and manage your devices
  * `az iot hub create --resource-group DEMO-IoTEdge --name {YOUR_IOTHUB_NAME} --sku F1` will create a *free* iot hub (limits: 8k messages per day and 500 registered devices)
* Azure Shell + IoT Cli Extension
  * Note: Easy way is utilizing [https://shell.azure.com](https://shell.azure.com) and run `az extension add --name azure-cli-iot-ext`
* Azure Edge Runtime on the device
  * Linux x64: [https://docs.microsoft.com/en-us/azure/iot-edge/how-to-install-iot-edge-linux](https://docs.microsoft.com/en-us/azure/iot-edge/how-to-install-iot-edge-linux?WT.mc_id=DT-MVP-5004263)
  * Linux ARM: [https://docs.microsoft.com/en-us/azure/iot-edge/how-to-install-iot-edge-linux-arm](https://docs.microsoft.com/en-us/azure/iot-edge/how-to-install-iot-edge-linux-arm?WT.mc_id=DT-MVP-5004263)
* An ARM IoT Device (we use ARM because it might give compatibility issues, but we will most likely have ARM devices in the field) 

## Registering a Device

### Creating a simulation device

Checking [IoT Edge Supported Devices](https://docs.microsoft.com/en-us/azure/iot-edge/support?WT.mc_id=IoT-MVP-5004263#operating-systems) showed me that Ubuntu 18.04 is supported on ARM. However since I didn't have access to a ARM device on the moment of writing, I went with deploying a VM on Azure, which is easily done through the marketplace: [https://azuremarketplace.microsoft.com/marketplace/apps/microsoft_iot_edge.iot_edge_vm_ubuntu](https://azuremarketplace.microsoft.com/marketplace/apps/microsoft_iot_edge.iot_edge_vm_ubuntu).

```bash
az vm create --resource-group DEMO-IoTEdge --name xavier-edge-1 --image microsoft_iot_edge:iot_edge_vm_ubuntu:ubuntu_1604_edgeruntimeonly:latest --admin-username xavier --ssh-key-values "YOUR_SSH_KEY" --size Standard_B1ms
```

> Note: if you are installing on an ARM, feel free to follow the guide at: [https://docs.microsoft.com/en-us/azure/iot-edge/how-to-install-iot-edge-linux-arm](https://docs.microsoft.com/en-us/azure/iot-edge/how-to-install-iot-edge-linux-arm?WT.mc_id=IoT-MVP-5004263)


### Creating an IoT Edge Device ID

Once our prerequisites are done, we can start adding our devices. For this run: `az iot hub device-identity create --hub-name {YOUR_IOTHUB_NAME} --device-id {YOUR_DEVICE_ID} --edge-enabled` which will create an edge-enabled device. This will return something like this:

```json
{
  "authentication": {
    "symmetricKey": {
      "primaryKey": "{MASKED}",
      "secondaryKey": "{MASKED}"
    },
    "type": "sas",
    "x509Thumbprint": {
      "primaryThumbprint": null,
      "secondaryThumbprint": null
    }
  },
  "capabilities": {
    "iotEdge": true
  },
  "cloudToDeviceMessageCount": 0,
  "connectionState": "Disconnected",
  "connectionStateUpdatedTime": "0001-01-01T00:00:00",
  "deviceId": "xavier-device-1",
  "deviceScope": "ms-azure-iot-edge://xavier-device-1-{ID}",
  "etag": "{ETAG}",
  "generationId": "{ID}",
  "lastActivityTime": "0001-01-01T00:00:00",
  "status": "enabled",
  "statusReason": null,
  "statusUpdatedTime": "0001-01-01T00:00:00"
}
```

## Connecting our IoT Edge Device to IoT Hub

Once we deployed this VM, we can now configure our IoT Edge by getting our IoT Hub connection string and running a shell command which is available in the image.

To get our connection string we can run:

```bash
az iot hub device-identity show-connection-string --device-id {YOUR_DEVICE_ID} --hub-name {YOUR_IOTHUB_NAME}
```


Which will return something such as:

```json
{
  "connectionString": "HostName={YOUR_IOTHUB}.azure-devices.net;DeviceId={YOUR_DEVICE_ID};SharedAccessKey={ACCESS_KEY}"
}
```

Now we can run the following script which was pre-deployed on our Edge Device through the Marketplace image, that will configure our edge device:

```bash
az vm run-command invoke -g Demo-IoTEdge -n {YOUR_EDGE_VM} --command-id RunShellScript --script "/etc/iotedge/configedge.sh '{YOUR_DEVICE_CONNECTION_STRING}'"
```

Which should show the following when executed successfully:

```bash
xavier@Azure:~$ az vm run-command invoke -g Demo-IoTEdge -n xavier-edge-1 --command-id RunShellScript --script "/etc/iotedge/configedge.sh 'HostName=xavier-iothub.azure-devices.net;DeviceId=xavier-device-1;SharedAccessKey={YOUR_DEVICE_ACCCESS_KEY}'"
{
  "value": [
    {
      "code": "ProvisioningState/succeeded",
      "displayStatus": "Provisioning succeeded",
      "level": "Info",
      "message": "Enable succeeded: \n[stdout]\n Wed May 22 13:24:14 UTC 2019 Connection string set to HostName=xavier-iothub.azure-devices.net;DeviceId=xavier-device-1;SharedAccessKey={YOUR_DEVICE_ACCCESS_KEY}\n\n[stderr]\n",
      "time": null
    }
  ]
}
```

> **Note:** You can now check if IoT Edge is running by SSHing on the machine and executing `sudo systemctl status iotedge`
> **Interesting Commands:** `journalctl -u iotedge` - Check logs, `sudo iotedge list` - Show modules running

## Creating our Edge Device's Echo Module

For testing purposes, we want to create a small container that echos the current time every 2 seconds to IoT Hub. To do this we follow a few steps:

1. **Command Palette (ctrl + p):** Azure: Sign In
2. **Command Palette (ctrl + p):** Azure IoT Edge: New IoT Edge solution
   * **Path:** /home/xavier/iot-edge/
   * **Solution:** EdgeSolutionCameraFilter
   * **Module Template:** C# Module
   * **Module Name:** EchoModule (our demo container for now)
   * **Docker Repository:** xavierregistry.azurecr.io/echomodule

> Note: for more information and details, check [https://docs.microsoft.com/en-us/azure/iot-edge/tutorial-csharp-module](https://docs.microsoft.com/en-us/azure/iot-edge/tutorial-csharp-module?WT.mc_id=IoT-MVP-5004263) which goes through the steps of creating a temperature model.

> Note 2: I didn't have docker installed on my machine. We can however easily work around this by utilizing a remote Linux VM Machine and use [VS Code Remote-SSH](https://code.visualstudio.com/docs/remote/remote-overview)

Once we did that, we will see the following boilerplate code created once we open our folder.

![./iothub-echo-module-creation.png](./iothub-echo-module-creation.png)

This boilerplate code creates a module that will play back our input on the output channel. To make this clearer, I renamed `input1` to `input-echo` and `output1` to `output-echo`.

![./iothub-echo-module-creation-2.png](./iothub-echo-module-creation-2.png)

Another thing I did is to add a timer that will send a message every 30 seconds to make it clear that it is actually doing something and that we don't necessarily have to send something to it ;) The code I used for that:

```csharp
// Register a Timer that will send every X seconds
var myTimer = new System.Timers.Timer();
myTimer.Elapsed += new System.Timers.ElapsedEventHandler((object source, System.Timers.ElapsedEventArgs e) => {
    var now = DateTime.Now.ToString("g");
    var message = new Message(Encoding.UTF8.GetBytes($"Sending event at {now}"));
    ioTHubModuleClient.SendEventAsync("output", message);
});
myTimer.Interval = 30 * 1000; // Every 30 seconds
myTimer.Enabled = true;
```

![./iothub-echo-module-creation-3.png](./iothub-echo-module-creation-3.png)

A last thing we now have to do is to remove a few lines from our `deployment.template.json` and `deployment.template.debug.json` file in the root folder: 

```json
"sensorToEchoModule": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/EchoModule/inputs/input1\")"
```

And some lines that deploy another module that we don't need

```json
"tempSensor": {
  "version": "1.0",
  "type": "docker",
  "status": "running",
  "restartPolicy": "always",
  "settings": {
    "image": "mcr.microsoft.com/azureiotedge-simulated-temperature-sensor:1.0",
    "createOptions": "{}"
  }
},
```

Now we are ready to build, publish and finally deploy our edge module.

## Building, Publishing & Deploying the Edge Module

### Building and Publishing our Edge Module

We can now easily build and publish our Edge Module by right-clicking our `deployment.template.json` and selecting "Build and Push Iot Edge Solution"

![./iothub-echo-module-creation-4.png](./iothub-echo-module-creation-4.png)

> **Note:** For me this failed due to permission issues on my Linux machine, however when you have the terminal open you can just press the up arrow and add `sudo` in the front. 
> **Hint:** ctrl + a jumps to the beginning of a line

This will now build and push our solution, resulting in:

```bash
# Docker container is building
Step 1/12 : FROM microsoft/dotnet:2.1-sdk AS build-env
2.1-sdk: Pulling from microsoft/dotnet
c5e155d5a1d1: Pull complete 
221d80d00ae9: Pull complete 
4250b3117dca: Pull complete 
3b7ca19181b2: Pull complete 
5980daa97e3c: Pull complete 
7cbae962589c: Pull complete 
4ab425e558b6: Pull complete 
Digest: sha256:481a526515bd95f7ecbe866b99ddac6130da3402e8e4fb09712123393d3f1475
Status: Downloaded newer image for microsoft/dotnet:2.1-sdk
 ---> 511c1f563ce6
Step 2/12 : WORKDIR /app
 ---> Running in ed3388ecf107
Removing intermediate container ed3388ecf107
 ---> e8033981828f
Step 3/12 : COPY *.csproj ./
 ---> 4614b845cc5d
Step 4/12 : RUN dotnet restore ---> Running in 2db5ed302e26  Restore completed in 3.24 sec for /app/EchoModule.csproj.
Removing intermediate container 2db5ed302e26
 ---> b74b9ac5490b
Step 5/12 : COPY . ./
 ---> 8132d7ecea0d
 Step 6/12 : RUN dotnet publish -c Release -o out
 ---> Running in 62098984d63d
Microsoft (R) Build Engine version 16.1.76+g14b0a930a7 for .NET Core
Copyright (C) Microsoft Corporation. All rights reserved.

  Restore completed in 485.11 ms for /app/EchoModule.csproj.
  EchoModule -> /app/bin/Release/netcoreapp2.1/EchoModule.dll
  EchoModule -> /app/out/
Removing intermediate container 62098984d63d
 ---> 46899da4cedb
Step 7/12 : FROM microsoft/dotnet:2.1-runtime-stretch-slim
2.1-runtime-stretch-slim: Pulling from microsoft/dotnet
743f2d6c1f65: Pull complete 
074da88b8de0: Pull complete 
ac831735b47a: Pull complete 
625946e33cc4: Pull complete 
Digest: sha256:5ff2b0f6e69b44f6404d46445be34408551331429d5a84b667cfee49ebd8117d
Status: Downloaded newer image for microsoft/dotnet:2.1-runtime-stretch-slim
 ---> f7da44fabfad
Step 8/12 : WORKDIR /app
 ---> Running in b999e9d179aa
Removing intermediate container b999e9d179aa
 ---> 247b2ac0a988
Step 9/12 : COPY --from=build-env /app/out ./
 ---> ef30f581b39d
Step 10/12 : RUN useradd -ms /bin/bash moduleuser
 ---> Running in 172a5e40a83e
Removing intermediate container 172a5e40a83e
 ---> dc3691450b75
Step 11/12 : USER moduleuser
 ---> Running in c71d5ab2fc77
Removing intermediate container c71d5ab2fc77
 ---> d4798c0654e7
Step 12/12 : ENTRYPOINT ["dotnet", "EchoModule.dll"]
 ---> Running in 547f0facbdd8
Removing intermediate container 547f0facbdd8
 ---> 114a7cc96b50
Successfully built 114a7cc96b50
Successfully tagged xavierregistry.azurecr.io/echomodule:0.0.1-amd64

# Pushing it
The push refers to repository [xavierregistry.azurecr.io/echomodule]
11e1e4b905fe: Pushed 
a0d529ad3f07: Pushed 
f081219e5aa6: Pushed 
be1595c6dfc4: Pushed 
ecf7942d9af2: Pushed 
ea4e5356527d: Pushed 
6270adb5794c: Pushed 
0.0.1-amd64: digest: sha256:7021323942c2323adb48d17ec73b00e69ec19216c816de59e2eb6e9a0b3f682c size: 1789
```

### Deploying our Edge Module

Now that our module is created and pushed to our repository, we can now push it to our Edge Module. For this, simply right-click on our device and select "Create Deployment for Single Device"

![./iothub-echo-module-deploy.png](./iothub-echo-module-deploy.png)

![./iothub-echo-module-deploy-2.png](./iothub-echo-module-deploy-2.png)

This will open up our output and show: 

```bash
[Edge] Start deployment to device [xavier-device-1]
[Edge] Deployment succeeded.
```

When we open up our device now, we can see that under modules we have an extra module deployed.

![./iothub-echo-module-deploy-3.png](./iothub-echo-module-deploy-3.png)

## Testing our Deployment

To monitor our device, we can now go to our devices and select "Start Monitoring Built-In Event Endpoint" which will open a logger for us. When we did this, we will now after a few seconds see:

```bash
[IoTHubMonitor] [5:59:27 PM] Message received from [xavier-device-1/EchoModule]:
"Sending event at 05/24/2019 17:59"
```

For our Echo module, we can now send a C2D message (Cloud to Device), we do this by Right-Clicking our device again and selecting "Send D2C Message to IoTHub" and entering our message.

When everything goes well we will now see the following in our Device Event Log:

```bash
[D2CMessage] Sending message to [IoT Hub] ...
[IoTHubMonitor] [6:02:36 PM] Message received from [xavier-device-1]:
"Hello World"
```

## Conclusion

We now created our first initial module, so let's get started for real now and work on [creating our AI Edge Module in Part 2](/post/2019/8/10/azure-javascript-iot-iot-edge-part2-simulator-car)!

Part 1 - Manage, Connect and Deploy our simulators to our Edge Devices with IoT Hub


Building an IoT Edge module is an important step for any IoT Application that requires on-edge processing to not constantly send data towards cloud (for bandwith, latency as well as processing reasons).

When you work with Azure IoT Edge, one of the issues you might have is that you would like to start debugging your applications before actually sending them off to your repository.

This article will explain you how you can do this for a `Dotnet Core` application using the simulator.

## Prerequisites

* IoT Hub
* IoT Hub Edge Simulator: `pip install --upgrade iotedgehubdev`
  * Note: I got a segfault while running the above, but adding `sudo` solved this - it's most likely related due to a right issue
  * Note 2: If you have to utilize `sudo`, first remove `iotedgehubdev` since it might be installed under `.local`
  * Note 3: Make sure `docker-compose` is also installed correctly (else if also under .local, reinstall with sudo)
* A module, see part 1 for this: [iot-edge-part-1](/post/2019/8/10/azure-javascript-iot-iot-edge-part1)

## Tl;dr

As a summary, you do the following:
1.  `sudo iotedgehubdev start -i "input1"` - Start the IoT Edge simulator for a single module
2. `cd <modulePath>` Navigate to your Module
3. `env $(sudo iotedgehubdev modulecred | xargs) dotnet run` - Start the module and test it (or through debug)

> Note: if when running the `env` command no output is appearing, make sure that you started the IoT Edge Simulator for a single module!

## Setting up the simulator

### Starting the simulator

Setting up the simulator requires an easy step:

`Azure IoT-Edge: Start IoT Edge Hub Simulator for Single Module` with a value for the input channel (default is `value1`). This will start a container up such as `mcr.microsoft.com/azureiotedge-testing-utility:1.0.0 ` which you see after running `docker ps`

This will give you the following output it everything went well:

```bash
xavier@PersonalVM:~/iot-edge/EdgeSolutionCarFilter/modules/ModuleSimulatorCar$ sudo iotedgehubdev start -i "input1"
IoT Edge Simulator has been started in single module mode.
Please run `iotedgehubdev modulecred` to get credential to connect your module.
And send message through:

        curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages

Please refer to https://github.com/Azure/iot-edge-testing-utility/blob/master/swagger.json for detail schema
```

Showing that a container is now running that will act as our `IoT Edge Hub` (remember, the Hub orchestrates messages from the edge devices to IoT Hub and Reverse - it's kind of a service bus).

### Getting the module credentials

When the simulator has now been started, we are able to get the credentials that are needed to connect our modules. You can get those by running: `iotedgehubdev modulecred` which will give an output such as this:

```bash
xavier@PersonalVM:~/iot-edge/EdgeSolutionCarFilter/modules/ModuleSimulatorCar$ sudo iotedgehubdev modulecred
EdgeHubConnectionString=HostName=<HOSTNAME>;GatewayHostName=personalvm;DeviceId=xavier-device-1;ModuleId=target;SharedAccessKey=<SHAREDACCESSKEY>
EdgeModuleCACertificateFile=/var/lib/iotedgehubdev/certs/edge-device-ca/cert/edge-device-ca.cert.pem
```

> Checking [https://github.com/Azure/azure-iot-sdk-csharp/blob/master/iothub/device/tests/Edge/EdgeModuleClientFactoryTest.cs](https://github.com/Azure/azure-iot-sdk-csharp/blob/master/iothub/device/tests/Edge/EdgeModuleClientFactoryTest.cs) we can see that these credentials are used to configure connection parameters.

## Running our code

Seeing that we now have our credentials, we can inject them as environment variables in our `dotnet run` command through this: `env $(sudo iotedgehubdev modulecred | xargs) dotnet run`

> What this will do is that it will run the `iotedgehubdev modulecred` command to get the variables, it will then put those on 1 single line and eventually use that line as a specific environment configuration to run our `dotnet run` command.

You will now see the module booting as such:

```bash
xavier@PersonalVM:~/iot-edge/EdgeSolutionCarFilter/modules/ModuleSimulatorCar$ env $(sudo iotedgehubdev modulecred | xargs) dotnet run
IoT Hub module client initialized.
<PROGRAM_OUTPUT>
```

Of course you are also able to utilize this as debug, for that feel free to check this link on how to set this up for your IDE: [https://docs.microsoft.com/en-us/azure/iot-edge/how-to-vs-code-develop-module#develop-your-module](https://docs.microsoft.com/en-us/azure/iot-edge/how-to-vs-code-develop-module?WT.mc_id=IoT-MVP-5004263#develop-your-module)

## Sending Messages to our module

Sending a message is now easy, once your code is running you are able to send messages by issueing a CURL request to the endpoint you received when starting the simulator (`curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages`)



Smart Retail with the AVNet MT3620 Starter Kit and an NFC scanner