Happiness is DevOps’ Cornerstone (Alexandre Brisebois) - Interesting post that asks a lot of questions... I would like to see some graph or pie chart about our answers.
5 Habits that Help Code Quality (View all posts by Erik Dietrich) - Yet another post about how to code better, but this one is refreshing. It explains why the opposite would be harmful and also give us a training plan for better chance of success.
What’s in your highlights folder? (Marc Gagne) - Because life is not only mistakes and bad luck.Here good tips to help you giving some sunshine into your life when needed.
Recently, I had to build a solution where Docker container were appropriate. The idea behind the container is that once there are built you just have to run it. While it's true, my journey was not exactly that, nothing dramatic, only few gotchas that I will explain while sharing my journey.
The Goal
The solution is classic, and this post will focus on a single Virtual Machine (VM). The Linux VM needs a container that automatically runs when the VM starts. Some files first download from a secure location (Azure blob storage) then passed to the container. The solution is deployed using Azure resources manager (ARM). For the simplicity, I will use Nginx container but the same principle applies to any container. Here is the diagram of the solution.
The Solution
I decided to use Azure CLI to deploy since this will be also the command-line used inside the Linux VM, but Azure PowerShell could do the same. We will be deploying an ARM template containing a Linux VM, and two VM-Extension: DockerExtension and CustomScriptForLinux. Once the VM is provisioned, a bash script will be downloaded by CustomScriptForLinux extension from the secure Azure blob storage myprojectsafe, then executed.
You are about to test the last version of your solution. You just need to change some configuration in the Micosoft Azure Portal, and you are good to go. To do it, you log in the portal at http://portal.azure.com and navigate to your component and... Error! What you see is a little sad cloud.
The Problem
This just happened to the team I'm working with. They needed to change the traffic manager's endpoint to do a traffic test. Unfortunately, the grid that contains the Endpoint was in a bad status and was not available. It looked like a deadened!
But it is really? Of course not. Here what you can do.
The Solution
Remember Microsoft is sharing the same API the Azure portal is using. That the beauty of the Azure Portal, you can use it has a convivial way to do your what you need, or you can access it via many different SDKs that are available today: .Net, Java, Node.js, Php, Python, Ruby and more! You also have command line tools that could help to manage your Azure services and apps using scripts.
To know more about all the SDK available or the command-line refer to the Azure SDKs documentation pages online.
This time we were in a Windows environment, and we needed to modify one Endpoint of a Taffic Manager. Here what we did using Azure PowerShell Cmdlets:
# Login to our account
Login-AzureRmAccount
# Set the context we will work in. Use Get-AzureRmSubscription to list all your subscriptions.
Set-AzureRmContext -SubscriptionName "MySubscriptionName"
# List All Traffic Manager Profile
Azure Get-AzureTrafficManagerProfile
# Load our endpoint in a variable, change the value we need and put it back.
$endpoint = Get-AzureRmTrafficManagerEndpoint -Name myendpoint -ProfileName myprofile -ResourceGroupName "MyResourceGroupName" -Type ExternalEndpoints
$endpoint.Weight = 50
Set-AzureRmTrafficManagerEndpoint -TrafficManagerEndpoint $endpoint
In this case, we used the Azure Resource Manager (ARM) commands, but all the commands are also available in the service mode. To know more about how to deploy with ARM you can read my previous post. To see all the command available supported with ARM to configure your solution, go see the documentation online.
Happy testing!
Check out Azure Test Drives in preview (Bryon Surace) - If you wanna test an application on Azure without subscription or anything... Look at test drives.
Detecting threats with Azure Security Center (Tomer Teller) - Interesting post that explains fundamental difference between servers and individual attack and introduces briefly Azure security center.
You know that image where you see people pulling a cart with square wheels, a man on the side wants to show them a circle wheel but the group reply they are too busy to care... Well, that was me with Azure Resource Manager (ARM). I knew it was good, but it looks too complicated, so I was waiting. Last weekend, I decided it was enough I needed to learn it! Right after few minutes, you cannot imagine my disappointment! It's so simple, so powerful and also so fast. This post explains how to deploy an ARM template, and how it works.
5 easy steps to deploy our first ARM template
To get started the easiest way possible I decided to use Visual Studio. For this sample let's create simple Windows Virtual Machine (VM). Only five steps are required to do it:
Step #1 - Create an Azure Resource Project
From Visual Studio create a new project of type Azure Resource Group. Be sure to have already installed on your machine the latest version of Azure SDK and Visual Studio updates.
Step #2 - Select the Arm template
This is where we select what we want in our template. Many options are available in VisualStudio and a lot more can be found on Github at: Azure Arm Git Template. In our case, let's select the sample Windows Virtual Machine, and click the Ok button.
Step #3 - Deploy the new template
Visual Studio will now generate multiple files, we will come back to it later, right now we will only deploy our solution. Right-click on the project et select Deploy.
Step #4 - Configure the deployment
Our first deployment is mostly ready, we just need to specify few details like the subscription and the resource group. Once you click Deploy, one last thing will be asked: the adminPassword.
Step #5 (the easiest one) - Enjoy
Voila! After few minutes, the virtual machine will be created, and we should be able to connect remotely to it.
Let's explain the magic
When the project was created, three folders were populated: Script, Template, and Tools. The last one is a bit obvious, it contains AzCopy, a tool to copy files. If you don't know AzCopy, you can learn more in a post I wrote recently.
Open the Deploy-AzureResourceGroup.ps1 contained in the Scripts folder. It's this script that will do all the hard lifting to deploy our rescourceGroup. If we look a bit closer, you will notice some parameters are declared, at the beginning of the file. Two of then should catch our attention.
TemplateFile is the path of our template (the one we selected previously), and the second TemplateParametersFile will contained all the parameters values to fill the blank of our template. This will be especially useful to deploy the same template in a different environment. In fact, this is a really big advantage. You can deploy the exact same schema to your development and production environment just by having two parameters.json file.
Let's have a peek at the template, in this case WindowsVirtualMachine.json. It's a 'json' file, so it's human-friendly, but it can be a bit scary at first. In the image just below, I collapse the collections to be able to emphases the visibility of the three prime elements: parameters, variables, and resources.
We already know parameters, so let's jump the variables. This section contains a list of key pair value like: imagePublisher, vmSize, virtualNetworkName, diagnosticsStorageAccountName, etc. Those can be fixed value or dynamics by using other variables or parameters. Here some example:
Last section but not least: the resources. This is where everything is put together to build the solution you will deploy. The resources are defined by specifying their type, name, and properties. You can assign any value from a static string, parameter value or a variable value.
Now that we know it works, why should we use it
Explain all the advantages to use ARM template could be a post by itself, and go further of the scope of that post. However, here few reasons:
A template file is light and easy to keep in a repository.
It's very simple to have the exact same template deployed in multiple environments.
ARM templates are really fast to deploy.
Easy to edit/ customize/ expand.
Easy to delete.
In Video Please
If you prefer, I also have a video version of this post.
Introducing docs.microsoft.com - Great post that explains all the nice features of the first glimpse of the new Microsoft documentation. They did a fantastic work, a post to read; a site to remember.
Cloud
Why Service Fabric? - You heard about the buzz word your tech guys are exited, but you would like to know why service fabric could be good for your business? This post is for you.
Suggestion of the week
