• Configure Liveness and Readiness Probes
• Kubernetes 201 -> Health Checking
• Container probes

• Change configuration so that container will crash at start up.
  • Example: Change value of readinessCheck from "true" to "true 123" (cannot be converted to boolean and causes failure in startup).
  • Deploy this update yaml and see how Kubernetes manages the situation (use e.g. "kubectl get pods" or "kubectl rollout status deployment kubernetesprobedemo").
  • Isn't this good place to catch configuration issues? Throw on startup to the rescue!
• Telemetry and probe events
  • If you collect telemetry from you application (e.g. Application Insights) then how do you handle telemetry events caused just by probes (hint)? You can calculate how much telemetry just your different services and their many instances generate from these probes.
• App health monitoring libraries
  • This demo application didn't use any ready made libraries but you should definitely check them out. Here's one good article in ASP.NET Core Health monitoring.

1. Create Git repository (or use existing if you have one)
2. Commit Blank ARM template starter kit files to the repository
3. Now you should have "clean" working state
4. Start loop
   • Add/Modify deployment script or ARM template
   • Execute deploy.ps1
   • Validate the change
   • Commit you change

Yes, it works for those new fancy apps but I have this old legacy <InsertYourTechnologyOrAppHere /> which cannot be automated and cannot be put to cloud just like that.

• Common Gateway Interface (CGI) app running under IIS
  • Written in C++
  • Reads information from registry
• Windows Service
  • Written in C++
  • Writes information to registry

How is the Windows Server configuration handled?

• Ensure that correct Windows features are installed (e.g. IIS and friends)
• Ensure that IIS is configured to be CGI app friendly
• Download our apps from Azure Storage to the VM
• Install and configure our apps

How did those applications land into the virtual machine?

What was that Pester in CD?

How does the final output look like?

Closing words

Bonus part

Closing words

• Continuous Integration (CI)
• Continuous Delivery (CD)
• Infrastructure as Code
• DevOps

1. Connect VSTS and Azure
2. Create repository for our application assets
3. Create build definition for continuous integration
4. Create release definition for continuous delivery
5. Code-Build-Deploy -loop

1. Connect VSTS and Azure

2. Create repository for our application assets

• deploy: this folder contains code and configuration files to create all the necessary resources to Azure (infrastructure code)
• src: this is actual source of the application
• test: Ooops… Missing in action !

3. Create build definition for continuous integration

Question: Why do you create this Web Deploy package and not just create connection directly from Visual Studio? Answer: Good question! I did that because it might not be yet known at development time where this will be deployed. You might start with 1 target environment (development) but later on get multiple environment so creating publishing profiles for them is no-go in my opinion. Target environments should not be "hardcoded" to source control.

4. Create release definition for continuous delivery

5. Code-Build-Deploy -loop

Closing words

• See how many solutions are still available
• Navigate between the solutions

Technical solution

In my previous post I explained how you can create solver which uses bottom up approach to solve this interesting problem. Now we're going to continue from that using MapReduce as our solving algorithm. If MapReduce is new concept to you then I would definitely recommend that you check out the Wikipedia article about it before reading this post. I'm going to take use of the concepts and terms mentioned in there so it might be a bit challenging without that base information.

Now we know (based on the previous posts) that we can solve My Pocket Solitaire nicely using bottom up approach. This gives us chance to identify steps we used during that process and now we can come up with new ways of running the same algorithm in different environment. If you recall my pseudo algorithm in previous post then we identified these following steps:

• We have list of unique positions in level one
• We execute moves for the each of the positions in the list
• We come up with new list of positions (includes possible duplicates)
• Remove duplicates away
• We have now list of unique positions in level two

And if you then slightly modify that above list of steps into this format:

• List of items
• Map each item with function
• We have new list of items based on output of function
• Reduce items from list based on function
• We have final output of items

This list awfully starts to look like Map and Reduce –like algorithm. So what if we built new version of our solving routine using MapReduce then? What we have to do in order to achieve that? First we will have to understand a bit more how you can put this kind of task into Apache Hadoop. To get easiest start on that journey you're quite easily routed into solution called Hadoop Streaming. Especially if you don’t have Java knowledge and you don't want to learn a lot of new stuff in order to get this implemented. I especially like the Practical Help section of Hadoop Streaming Wiki Page which gives you simple and direct way to get started with development locally and then learn more after that. Their script sample actually directly translates in my head into this:

type SolverInit.txt | SolverMapper.exe | SolverReducer.exe

This means that we have some kind of "SolverInit.txt" providing input into our process which is then executed through our "SolverMapper.exe" and that output is then put through "SolverReducer.exe". Output of reducer would be then again something that our solver would be able to use again when executed through MapReduce.

In order to implement this we have to now understand more about the input format. So what is this "SolverInit.txt" file then? Again we take a look at Hadoop Streaming documentation which clearly says that input is coming in standard input stream (stdin) as lines into MapReduce processes and each line contains key-value pair. Key is until first tab on that line and rest of the line is considered to be value (this is the default setup but it can be changed).

So now we need to come up with format that has each game position in one line and key would position of the board. And since we want to now calculate again the magic number (which we already managed to solve in previous post) then we need to have count of solutions behind that key as counter. We also put there moves so that we can later validate that is this correct solution path. This leads us into this format for the "SolverInit.txt":

65536	1	

Key for that is coming from board position (final board position in string format is 000000000000000010000000000000000) which is then converted using Bin->Dec conversion (from bits to number). You might be wondering that why I chose this format and not directly the string format… well reason is that since I was doing this in my local laptop and was forced to squeeze the data elements in order to be able to execute my algorithms . And even if you start to utilize distributed processing model like this you still have the responsibility to keep in mind that how do you balance with the CPU, network data transfer need and storage use. But I might do another post with even simpler set up later.

"SolverMapper.exe" and "SolverReducer.exe" implementations have actually quite small responsibility in this entire solution. Mapper takes board positions as input from single line and performs all the possible available backward moves and outputs these new board positions as new lines to the output stream. Reducer in turn reads incoming lines and if there are multiple lines with same key (note: Hadoop hands these lines in sorted order of keys) then it will output just single line with value which is sum of all those duplicate lines.

So if we now think conceptually this MapReduce in My Pocket Solitaire context we can maybe best describe the process using this kind of batch file (lines omitted for simplicity):

type SolverInit.txt |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe |^
SolverMapper.exe | sort | SolverReducer.exe

That pretty much demonstrates that what kind of process this MapReduce streaming actually is!

How to run this in HDInsight then?

Okay now we have some understanding that how could we run this streaming job but what's the best way to do it then? And here comes the nice part of Azure HDInsight. You can actually built nice PowerShell script that runs this entire solving process as automated process. You just need to have Azure subscription and you're good to go! You might want to read this excellent article before you proceed because I won’t go necessarily through all the details to set you up.

Of course I can login to the management portal and create HDInsight clusters etc from there but since I'm now going to demo how you can do this using just script then we need to do something extra to set it up. In order to script to work without you providing credentials to it, it needs use certificate in order to access the service. When access is solved in script then script would have to create needed storage account, create HDInsight cluster, run the entire MapReduce algorithm loop for 32 levels and then get the final output file out from storage. And of course when this process is completed it will release all the resources created during the script execution. And while script is doing the heavy work (or more precisely Azure is doing the heavy work ) then you can be somewhere else doing something completely different.

So in order to get the automatic login to work you have to download so called publish settings. You can get it using Azure PowerShell and executing following command there:

# Get Azure publish settings file using this command:
Get-AzurePublishSettingsFile

This will open up browser and it will spit out you file from Azure which will contain management certificate in there. This file allows you to run these scripts as unattended. But this of course means that you have make sure that proper security is applied when handling this file. Read more information from here. In my solver script I have the call to import this publish settings file in order to demonstrate that how this full end to end process can be implemented. My script expects that to be saved into same folder as the script itself using name "Subscription.publishsettings".

What to expect when you then execute "Solve.bat" (which is wrapper to start the real PowerShell script to make sure that it actually doesn't just open that script file but rather executes it):

@powershell.exe -NoProfile -InputFormat none -ExecutionPolicy unrestricted -File %~dp0Solve.ps1

Well you should see PowerShell script starting the execution and providing updates about the progress:

If you want to run this script by yourself then you can just get all the resources from here.

Here’s the full "Solve.ps1" script that makes all these tricks:

# Full Solve.ps1 will be here if you view this blog post through web browser 

NOTE: If you want to use this script then you have to modify top part of in order to use your correct Azure Subscription name and correct management certificate. And you have to also change the Azure resource names (storage, HDInsight) so that you have unique names for those resources.

After the process you end up with "Input32/part-00000" file in your local folder:

6442450943	10215411760019992	OQDPKIPD2PUWGUXVZXUWMKXJJLP2AIHJ1M5W7Y6XR4WYMK4RJLCKSQBJQELJJB
8589410303	10215411760019992	EQHJAIPDNPQOSQ4R1YR4CA7YXZ2PAIJHM1LJ1YQEFD6XYWGIP25WDPP2UW2PPN
8589869055	40861647040079968	SQ4RWYR47YZXUWFRMKXV5WJL1M6XMKP2HJGUAIUW2PPDRFCKKIQ3DPOQBJJX3Q
8589926399	10215411760019992	OQDPGIUGWU5WXVZX7YXZ1YR4JHGIFRMKRFTRCKRFPDACCKDF6XUWFRQSWY4RRT
8589934589	10215411760019992	SQ4RWYR47YZXUWFRMKXV5WJL1M6XMKP2HJGUAIUW2PPDRFCKKIQ3DPOQBJJXX6

And that of course contains that magical number in the third row.

Okay we have now demonstrated that we can use HDInsight to run our Hadoop Streaming tasks. Of course this kind of solving task is far from optimal (in performance wise and just by pure solution wise) for our problem but it’s still quite cool way to run the actual solving process . Now go and implement your own algorithms and logics using Azure PowerShell!

Anyways... Happy hacking!

J

In my previous post I went through how to solve this puzzle using top-down approach. However as I explained it’s quite inefficient way to just “brute force” the tree from Top-Down and try to get possible solutions.

So what if we would like to know that how many unique solutions there are in this puzzle? Getting solution for that question using Top-Down method would take very long time… therefore we need other ways to answer that question. This brings us to Bottom-Up method which is pretty good fit for this kind of problem. More about Top-Down and Bottom-Up design in Wikipedia.

Idea of bottom-up solving starts from the core idea that since we know the desired target state of the board (a.k.a. end state) then we can use that information to remove a lot of unwanted board states during processing. If you compare this to Top-Down then you don’t actually know that does this certain selected tree path ever lead to target board state. And since you have to process the tree to last possible state before you can say that did we reach the target state or no… you’ll do a lot of unnecessary work. And in simple terms…. if you do a lot of unnecessary work you end up being slow and vise versa . In Bottom-Up method we can remove a lot of unnecessary work because we *know* that we’re starting from *valid* end position and all the paths to the root contribute to the final solution count.

Of course there is downside in this solution =>This  is more complex solution than the standard Top-Down approach. So if you want to use this kind of algorithms in your own applications then you need to pay more attention when implementing it. Next I’ll try to describe Bottom-Up approach so that it would make sense to you. Here’s the Pseudocode of it:

Initialize list of previous board states with target state of board
Initialize list of board states to empty

Loop 31 times
  Clear list of board states
  For each board state in list of previous board states
    Restore board state to current board state
    Get list of valid backward moves from this current board state
    For each move in valid backward moves list
      Make backward move from this current board state
      Store new board state to list of board states
		
  Aggegate all board states in the list of board states
  Set list of previous board states to be list of board states
  
End result is at the list of previous board states

First we have create lists where we store information about board states that the algorithm is currently working on. Then we start loop which we’ll repeat 31 times (depth of the solution tree ). Inside that loop we’ll restore previously stored board state. Then we’ll do all the possible backward moves from that board state so that we get new board states but all of them are one level up in the solution tree (and thus the Bottom-Up naming). Since we’re restoring one-by-one all the previously stored board states and then getting all board states of one level up from those we’ll might be getting duplicate board states at the end. Therefore we need to “aggregate” (or “group”) those duplicates away. And when we have repeated this logic for 31 times we’ll be having list with 5 items which describe the board state where all the paths led to. You might be wondering that how come 5 items in the list since only 1 would be correct answer but I’ll answer that later.

Let’s walkthrough the implementation step-by-step. So first we set the board to end state:

From this end state we have to get valid backward moves. Valid moves are highlighted in the above image with red arrows.

Next we try to remove duplicates board states but there isn’t yet duplicates in this first round. Then we’ll store these 4 board states to list and continue with next iteration of the loop. Again we’ll get valid backward moves but this time we have to repeat the process for all 4 board states that we have stored earlier. This will give us then 12 new board states in this iteration (see previous post which has table and graph about the growing ratio). And again there are no duplicates in this round so we can continue to next iteration. which gives us 60 new board states and no duplicates. However next iteration is interesting since we’ll get 400 new board states but when we get rid of the duplicates we will be left with only 296 new board states. This means that there are quite many paths that lead to exactly same board state. And since we’re now focusing to answer the question that “how many unique solutions there are in this puzzle” we can safely get rid of the duplicates. And if you can get rid of 100+ unnecessary calculations in one level you can just imagine what this does to performance in the long run! But of course we cannot just blindly remove duplicates because that would lead to wrong end result. We have to aggregate those solution counts together before we ignore the duplicate. This just means that if two paths come together then you have to make sure that you count them together that you know how many times you can end up to the final position from this particular position.

Then we’ll just keep repeating above formula until we’re left to the last position on the board. Maybe surprisingly there are suddenly five board positions still left. One of them is the real solution where the last missing piece is really in the middle of board. Other four solutions are marked with yellow color:

Magic number

And this solution with the green color will give us magical number of 40861647040079968 (formatted: 40’861’647’040’079’968). That is so large number that Excel displays it like this: 4.086E+16. So you can say that this game has 40 petasolutions! Similarly you end up to these yellow (from above picture) start positions and they have each 10215411760019992 solutions (I mean that if you would start from that position you would end up to final position with this many different routes). If you them sum up these four yellow start up position solutions then it will lead again to same magic number 40861647040079968 .

How long does it take to calculate this?

If you want to compare this to the Top-Down approach (or Bottom-Up but without “grouping” of similar board positions) then I think below picture tells it all. X-axis is the depth of the tree in processing and Y-axis is the number of board positions:

From that it’s quite easy to see that you optimize the performance a lot because you can eliminate duplicate board positions away and thus don’t waste any energy on processing them.

I have implemented this Algorithm in C++ using different mechanisms such as:

1. Single thread
2. Multithread
3. Parallel Patterns Library (PPL)
4. Mapper-Reducer – Multiple processes (more about this in future posts)

Multithread approach takes on my laptop 1,5 hours! This is not bad if you take into consideration complexity of the given task.

Hopefully you got an idea how you could use Bottom-Up method to solve some tough problems. In future posts I’ll open up more different implementations such as mapper-reducer etc.

Anyways... Happy hacking!

J

This time we’re starting to open up the solving logic for this puzzle. Playing of the game starts from the initial position:

From that initial state you should end up into this target state:

In order to achieve that you have to make series of valid moves where you jump over piece with another piece into empty space and then you remove the piece which got “jumped over” (read more from here).

Now we have actually defined all the necessary definitions what we need in order to proceed further:

• Initial state
• Valid move
• Target state

And us human beings tend to solve these kind of puzzles using “top-down” thinking. It’s easiest way to start but at the same time it’s extremely inefficient. But before we’ll talk more about the efficiency part let’s take a look at Pseudocode about this top-down solving logic:

Solve 
  Validate board state
  If board is at the target state
    Hurray!
  Else
    Get list of valid moves for current state
    For each move in valid moves list
      Make move
	  Recursively call Solve
      Undo move

Program
  Initialize board to initial state
  Call Solve

You can see that this Algorithm is very simple and into some extend it even models “human thinking” (but when humans tend to get stuck they go back to the initial state instead of recovering to the previous state). Pseudo program starts from the line 12 and it first initializes board to initial state and then it calls recursive method called Solve. Solve follows simple logic:

1. Am I already at the target state? If yes then Hurray!
2. If no which means we have to take all available valid moves from current board state
3. For each of the available board moves make move and recursively call Solve
4. When call returns back then undo previous move (recover to state where we still had options)

This logic is easy to read and easy to implement. So if you’re just starting programming I think this is good exercise to get you started with algorithms .

However as I mentioned it’s inefficient. So how *bad* is the performance of this then? Well simple diagram demonstrates it pretty well (click image to see it larger):

X-axis of the diagram is tree level in solution. Meaning level 1 indicates initial state where there are 4 valid moves available (in another words 4 subtrees from that given position). Level 2 already has 12 subtrees etc. You can better see this from this table:

Y-axis of the diagram is count of subtrees in logarithmic scale. So it’s pretty easy to understand from the diagram that count of subtrees pretty much explodes. It just means that if you use this “top-down” method when solving this (or similar logical problems) you’ll end up into poor performance IF your target is to maximize the solving performance.

Quite often when I talk about this kind of logical problems with someone I get these kind of comments (or very similar): “Just add some parallel execution to it and it’s way faster then”. Well I don’t think that you should use horse power to solve problems if you’re using completely wrong algorithm . First you implement better algorithm (and I prefer to do it with single thread approach since it has many advantages and maybe I’ll come back to this in the future posts) and then you can think how to leverage available horse power from the machine(s). But remember that horse power doesn’t ever fix bad algorithm.

And if you would like to know how many unique solutions there are in this board game then you wouldn’t get answer to your question when implemented using this method. In future posts we’ll cover that topic too.

Anyways... Happy hacking!

J