Visualizing ARM templates with ARMata

Some time ago I wrote a short post about a tool for visualizing ARM templates called ARMVIZ - while it's perfect for simple scenarios, it lacks more advanced features like toolbox, generating an image of architecture or quick recap of a resource. It also has problems with larger templates, which are barely readable and unfortunately is no longer maintained - at least at this moment. After discussing this problem with a group of Polish developers, we decided, that it'd great to create a new tool with extended functionality, which would take place of ARMVIZ in the future. This is how ARMata project was born.


ARMata differs greatly since it is no longer a web application - it is built with Electron so basically you can run it whenever Electron works(and since it is cross-platform, it works literally everywhere). Since you're installing it on your computer, it can perform much more advanced actions like editing files on your disk, using hardware acceleration for visualizing a template or interacting with other programs. It comes with automatic updates so you can be always up-to-date with all fresh features.

Open source

Yes - it is open source and completely free - you can take it, use it and modify it without limits. The goal is to create a tool, which is accessible for as many people as possible, eases working with ARM templates(which can be really cumbersome) and speeds up development. What is more - you can help in achieving this goals at any time by reporting bugs, introducing UI changes or coding new features. 

Current status

Currently ARMata is at the beta stage with main functionalities like parsing a template, visualizing it or quick recap of a resource already implemented. There're even more ideas, which will be introduced sooner or later like:

  • live editing of a template
  • toolbox with a possibility to create a template from scratch
  • generating an image from a visualized template so it can be used in documentation

If you'd like to help, we'll be more than happy to welcome you - there's still many thing to do :)

Durable Functions - Durable Task Framework basics

In the previous post I presented some basic concepts behind Durable Functions and reasoning why they've been introduced and what we can achieve with them. This time I'll focus on the very foundation of Durable Functions - Durable Task Framework - and its features. We'll try to understand its mechanics and build a very simple workflow to get an idea how it works. Let's go!


The basic concept of Durable Task Framework is to use Service Bus to orchestrate work and use it as a temporary storage for a state. When Framework is initialized, it creates a Service Bus queue under the hood, which will be used as a the main components to pass messages. Note that queue size is not unrestricted - you have to choose on of the following values:

  • 1024MB
  • 2048MB
  • 3072MB
  • 4096MB
  • 5120MB

any other size will be treated as an error and will result in an exception.

 If you go to Core Concepts sections for Durable Task Framework, you can find following diagram:

It shows the underlying structure of Durable Task Framework and all main elements of the architecture. It may be a little confusing now, but once we start creating orchestrations, all will become easier to understand.

The most important thing here is Task Hub Worker, which allows adding Task Orchiestrations and Task Activities and dispatching to these - to make the long story short, it acts as foundation of your solution.

The difference between Orchiestration and Activity is fairly simple - once Activity is the actual action, which should be performed and we can refer to it as a simple and atomic task, which will be executed, Orchiestration is thing, which aggregates Activities and orchestrates them. You can think about it as a conductor, which is responsible for going the right path.

From Durable Tasks to Durable Functions

You may ask "how do Durable Tasks connect to Durable Functions?" - in fact initially there's no explicit connection. We have to consider what would be the best way to achieve orchestration in the world of serverless. In the previous post I mentioned, that current solution includes using Azure Storage queues, what for sure lets you achieve the goal, but is far from ideal solution. Natural evolution of this idea is to utilize something what is called event sourcing and instead of pushing and fetching messages from queues, just raise an event and wait for an eventual response:

  • Function1 started executing
  • Function1 called Function2
  • Function2 started executing
  • Function2 finished executing
  • Function1 called Function3
  • Function1 finished executing

This is a trivial concept but yet a really powerful one. By storing a state in a such manner(using an append-only log) you're gaining many profits:

  • there's no way to mutate a state with appending another event
  • immutable state - difficult to corrupt
  • no locking
  • it' easy to recreate a state if needed 

Now if you consider, that Activities can be treated as events, there's an easy way to Durable Functions, where each Activity is another function and a state is stored in Azure Storage and maintained by the runtime.


Today we went a bit deeper into Durable Task Framework and considered connection between this library and Durable Functions. In the next post I'll try to present a basic example of Durable Function and what changes in that approach when creating serverless application.