DEV Community: Mega Therion AS

Migrating repos from Atlassian Stash to Azure DevOps

Alexander Viken — Fri, 23 Oct 2020 23:07:29 +0000

Here is a guide on how I helped a cliend move from an internal, on-prem installation of Atlassian Stash to Azure DevOps using PowerShell and Azure CLI. Not sure if this is helpful for others, but it might in light of Atlassians lates announcment to discontinue their Server products by early 2024. I am not sure if the Stash system is part of this, but here is a guide anyhow.

To use this you'll need powershell, git and Azure CLI installed. in addition you need to add the azure devops extension to Azure CLI

d:\repos>az extension add --name azure-devops

The next you will need to do is to login to your Azure DevOps organizaton and generate a Personal Access Token (PAT). You can find it here: https://dev.azure.com/{your_organization}/_usersSettings/tokens

d:\repos>az devops login
Token:

paste in the PAT at the "Token" prompt and you are logged in to DevOps via the CLI.

The organization I was working with had a lot of projects in Stash, with several repositories in each project. I only needed to do this for a single project so there was no need to do it at a higher level, but extending this to add a feature for looping through all projects in stash, then add a feature to create new projects in Azure DevOps to match the stash projects should be a minor change. Also, I haven't added any error handling so this is all happy path coding so if you are uncertain about your environment you should probably add some error handling and checks in the code.

My first function is for retrieving a list of all repos for a project in Stash using the built in Stash API. I am not sure how this Works on different versions of Stash so it might need changes if you have newer/older versions. Also, if you have more than 50 repos in the project increase the number with the limit parameter in the url.

function GetStashReposForProject($user, $pass, $stashHost, $projectKey)
{
    $pair = "$($user):$($pass)"
    $encodedCreds = [System.Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes($pair))
    $basicAuthValue = "Basic $encodedCreds"
    $Headers = @{
        Authorization = $basicAuthValue
    }
    $uri = $stashHost + "/rest/api/1.0/projects/"+ $projectKey + "/repos?limit=50"
    $request = Invoke-WebRequest -Uri $uri -Headers $Headers
    $repos = $request.Content | ConvertFrom-Json
    return $repos.values
}

With this method we get a full payload with all the repos listed as part of the @repos.values return value.

The next function clones the stash repo onto the workstation and sets the stash $clone_uri as remotes/origin by default. The function creates a folder for the repo. It is based on where you execute the code, so make sure you are on a disk with enough space and have a clean "root" folder to work from.

function CloneStashRepository($clone_url, $repo_name)
{
    mkdir $repo_name
    cd $repo_name
    $gitclone = "/c git clone " + $clone_url + " ."
    Start-Process cmd -Argument $gitclone -Wait
}

Next we need a function that checks out all the branches in the repository so that it can later be pushed to DevOps.

function CheckoutAllBranches() 
{
    $branches = git branch --all
    foreach($branch in $branches)
    {
        if ($branch -like "*remotes/*") 
        {
            $branchName = $branch -replace "remotes/origin/" -replace ""
            $gitCheckout = "/c git checkout " + $branchName
            Start-Process cmd -Argument $gitCheckout -Wait
            Write-Host('checkedout branch: '+ $branchName )
       }
    }
}

Now that I have all the branches for the repo locally on my machine I need to choose what project in Azure DevOps they should be pushed to.

function SelectAzureDevOpsProject($devOpsOrg)
{
    $projects = $(az devops project list --org $devOpsOrg -o json) | ConvertFrom-Json

    $count = 1
    foreach($p in $projects.value)
    {
        Write-Host $count ") " $p.name
        $count++
    }
    $index = Read-Host "Chooose project (enter number)"
    #Write-Host "Selected inde is: " $index
    $sp = $projects.value[$index-1]
    $arr = @($sp.id, $sp.name)
    Write-Host "Selected Project name: " $arr[1]
    return $arr
}

This function returns an array that has the guid and the name of the project we want to use.

A small function handles creating the new repo in Azure DevOps

function CreateRepoInDevOpsProject($slug, $projectId, $devOpsOrg) 
{
    az repos create --name $slug --project $projectId --organization $devOpsOrg
}

The final worker function adds the devops repo as remote named devops in the local repository. Then loops through all the local branches and pushes them to the remote devops repo.

function PushToDevops($orgPath, $project_name, $repo_name) 
{
    $projectName = [uri]::EscapeDataString($project_name)
    $slug = [uri]::EscapeDataString($repo_name)
    $remoteUrl = "https://$orgPath@dev.azure.com/$orgPath/$projectName/_git/$slug"
    $makeRemote = git remote add devops $remoteUrl

    $branches = git branch
    foreach($branch in $branches)
    {
        $gitCheckout = "/c git push devops " + $branch 
        Start-Process cmd -Argument $gitCheckout -Wait
        Write-Host('pushed branch: '+ $branch )
    }
}

Finally, the code block that is run when the ps1 file is executed.

$user = Read-Host "Enter Stash Username"
$pass = Read-Host -AsSecureString "Enter Stash Password "
$stashHost = Read-Host "http://domain:port"
$projectKey = Read-Host "Enter stash project key"
$devOpsOrg = Read-Host "https://dev.azure.com/"
$orgUri = "https://dev.azure.com/" + $devOpsOrg

$selectedDevOpsProject = SelectAzureDevOpsProject $orgUri
$selectedDevOpsProjectId = $selectedDevOpsProject[0]
$selectedDevOpsProjectName = $selectedDevOpsProject[1]

foreach($repos in GetStashReposForProject $user $pass $stashHost $projectKey -Wait)
{
    $slug = $repos.slug
    CloneStashRepository $repos.cloneUrl $slug -Wait
    CheckoutAllBranches -Wait
    CreateRepoInDevOpsProject $slug $selectedDevOpsProjectId $orgUri -Wait
    PushToDevops $devOpsOrg $selectedDevOpsProjectName $slug -Wait
    #Jump out of working folder and back to root so the loop know where to start.
    cd ..
}
Write-Host "*********************************** IMPORT COMPLETE ***********************************"

The full script should look something like this. You can copy the code and save it to a ps1 file. To run it you probably need to change your execution policy, or sign the script.

function CheckoutAllBranches() 
{
    $branches = git branch --all
    foreach($branch in $branches)
    {
        if ($branch -like "*remotes/*") 
        {
            $branchName = $branch -replace "remotes/origin/" -replace ""
            $gitCheckout = "/c git checkout " + $branchName
            Start-Process cmd -Argument $gitCheckout -Wait
            Write-Host('checkedout branch: '+ $branchName )
       }
    }
}
function CloneStashRepository($clone_url, $repo_name)
{
    mkdir $repo_name
    cd $repo_name
    $gitclone = "/c git clone " + $clone_url + " ."
    Start-Process cmd -Argument $gitclone -Wait
}
function PushToDevops($orgPath, $project_name, $repo_name) 
{
    $projectName = [uri]::EscapeDataString($project_name)
    $slug = [uri]::EscapeDataString($repo_name)
    $remoteUrl = "https://$orgPath@dev.azure.com/$orgPath/$projectName/_git/$slug"
    $makeRemote = git remote add devops $remoteUrl
    $branches = git branch
    foreach($branch in $branches)
    {
        $gitCheckout = "/c git push devops " + $branch 
        Start-Process cmd -Argument $gitCheckout -Wait
        Write-Host('pushed branch: '+ $branch )
    }
}
function GetStashReposForProject($user, $pass, $stashHost, $projectKey)
{
    $pair = "$($user):$($pass)"
    $encodedCreds = [System.Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes($pair))
    $basicAuthValue = "Basic $encodedCreds"
    $Headers = @{
        Authorization = $basicAuthValue
    }
    $uri = $stashHost + "/rest/api/1.0/projects/"+ $projectKey + "/repos?limit=50"
    $request = Invoke-WebRequest -Uri $uri -Headers $Headers
    $repos = $request.Content | ConvertFrom-Json
    return $repos.values
}
function SelectAzureDevOpsProject($devOpsOrg)
{
    $projects = $(az devops project list --org $devOpsOrg -o json) | ConvertFrom-Json
    $count = 1
    foreach($p in $projects.value)
    {
        Write-Host $count ") " $p.name
        $count++
    }
    $index = Read-Host "Chooose project (enter number)"
    #Write-Host "Selected inde is: " $index
    $sp = $projects.value[$index-1]
    $arr = @($sp.id, $sp.name)
    Write-Host "Selected Project name: " $arr[1]
    return $arr
}
function CreateRepoInDevOpsProject($slug, $projectId, $devOpsOrg) 
{
    az repos create --name $slug --project $projectId --organization $devOpsOrg
}

$user = Read-Host "Enter Stash Username: "
$pass = Read-Host "Enter Stash Password: "
$stashHost = Read-Host "htp://domain:port"
$projectKey = Read-Host "Enter stash project key"
$devOpsOrg = Read-Host "https://dev.azure.com/"
$orgUri = "https://dev.azure.com/" + $devOpsOrg
$selectedDevOpsProject = SelectAzureDevOpsProject $orgUri
$selectedDevOpsProjectId = $selectedDevOpsProject[0]
$selectedDevOpsProjectName = $selectedDevOpsProject[1]
foreach($repos in GetStashReposForProject $user $pass $stashHost $projectKey -Wait)
{
    $slug = $repos.slug
    CloneStashRepository $repos.cloneUrl $slug -Wait
    CheckoutAllBranches -Wait
    CreateRepoInDevOpsProject $slug $selectedDevOpsProjectId $orgUri -Wait
    PushToDevops $devOpsOrg $selectedDevOpsProjectName $slug -Wait
    #Jump out of working folder and back to root so the loop know where to start.
    cd ..
}
Write-Host "*********************************** IMPORT COMPLETE ***********************************"

Disclaimer

All code here is provided as is. I take no responsibility for any damage that might occur, economic and technical if you choose to use it. Add validation and error handling if you plan to use this in automation.

Moving internal git repo to devops or github using PowerShell

Alexander Viken — Thu, 22 Oct 2020 14:19:38 +0000

I just started working with a new customer, to help them modernize their software development. One of the first tasks we decided on was to discontinue their use of Atlassian Stash for managing their repositories, and move to Azure DevOps so we could use both repos and pipelines.

Our first issue was that the Stash server didn't have an internet reachable endpoint, it was only available on the internal network. The second was that over the years with somewhat unplanned git usage there was a huge amount of branches they needed and wanted for historic purposes, so the only option was to move everything, all branches.

I didn't find any good tools to automate this, to move everyting, of the box so I decided to write a couple of powershell functions to help me.
First, a function for checkout of the stash branches to my workstation, then a function to push them to an Azure Repo.

I had already cloned the repository from Stash so it was set up with the stash repo url as origin so the first function loops through all branches and checks out all remotes/origin branches.

function CheckoutAllBranches() 
{

$branches = git branch --all

    foreach($branch in $branches)
    {
        if ($branch -like "*remotes/*") 
        {
            $branchName = $branch -replace "remotes/origin/" -replace ""
            $gitCheckout = "/c git checkout " + $branchName
            Start-Process cmd -Argument $gitCheckout -Wait
            Write-Host('checkedout branch: '+ $branchName )
       }
    }
}

The second function loops through all the local branches and pushes them to the Azure Repo.

function PushToDevops() 
{
    $makeRemote = git remote add devops [url_to_azure_repo] 
    $branches = git branch
    foreach($branch in $branches)
    {
        $gitPush = "/c git push devops " + $branch 
        Start-Process cmd -Argument $gitPush -Wait
        Write-Host('pushed branch: '+ $branchName )
    }
}

I saved them to a ps1 file and executed the ps1 script file. I then cd'ed into the folder where I cloned the stash repo and run the checkout function:

d:\repos\myrepo\>CheckoutAllBranches

Depending on how many branches you have - just wait. When It's done run the second function

d:\repos\myrepo\>PushToDevops

Pretty simple, but I haven't found any better tool that will let med move a big repository from private on-prem to external repo.

Using Azure CLI and Powershell to create Kubernetes cluster in Azure

Alexander Viken — Sun, 19 Jan 2020 16:32:07 +0000

Here's a guide on how to set up a Azure Kubernetes Service cluster using Azure CLI and powershell. I use this environment to set up a default cluster for testing and it takes me about 3 minutes to set up a full basic environment for dev/test.

A tip, I use VSCode and the Azure CLI tool plugin with Powershell Core. This gives me almost the same functionality as I get through the Powershell ISE.

Requirements:

Powershell (Install instructions)
Azure CLI (Install instructions)
kubectl

Once you have Powershell and Azure CLI installed run

az aks install-cli

to install the kubectl client. Follow the instruction to set up the environment variable in system.

Open VSCode, or any other text editor and start building your script.

First thing first..

#login to your azure subscripiton
az login

#see your subscriptions
az account list

#set active subscription if you have more than one
az account set --name "<name of your azure subscripiton>"

First we define the variables we need to use. change the value of the variables as you see fit. I am choosing location "North Europe" since I am in Norway but important part is that your AKS name must be unique within the location/region you choose and if you plan to deploy ACS also it's name must be globally unique.

# general
$location = "northeurope"
$aksrg = "cluster_rg"

# VNET##
$vnet = "cluster-vnet"
$vnet_address_range = "10.0.0.0/16"

# aks subnet
$akssn = "aks-sn"
$aks_cidr = "10.0.2.0/23"

# aks
$aks = "<define a unique name for your cluster (unique within $location)>"
$aks_srv_cidr = "192.168.6.0/23"
$aks_dns_ip = "192.168.6.10"
$aks_pod_cidr = "192.168.8.0/21"
$aks_docker_bridge = "172.17.0.1/16"

# acr
$registry = "<define a globally unique name for your registry>"

Next we will create some resources. We start with our resource group and then create the virtual network and subnet.

# create the resource group
az group create --name $aksrg --location $location

# define a VNET
az network vnet create --name $vnet --resource-group $aksrg --address-prefixes 
$vnet_address_range

# create the AKS subnet inside the vnet
az network vnet subnet create -g $aksrg --vnet-name $vnet -n $akssn --address-prefixes $aks_cidr

# get id of the vnet
$vnetid = $(az network vnet show -n $vnet -g $aksrg --query id --output tsv)

# get the id of the subnet
$akssnid = $(az network vnet subnet show -g $aksrg --vnet-name $vnet -n $akssn --query id --output tsv)

We also need to create a service principal that enables the AKS service to interact with the virtual network we created. One tip I have while working with Azure CLI and powershell is to install "jq". It is a lightweight and flexible command-line JSON processor that can be installed through Chocolatey. All of the Azure CLI commands can output json response values by applying the switch "--output json" to the command.
If you want your service principal to be a bit easier to spot in AAD you can attach a name to to the SP using the --name switch (ie: --name "${aks}_sp"). Also, if you attach name to the service principal and don't remove it in clean up, it'll be reused and patched the next time you run the script.

#create the service prinsipal and store the output in a json file
$outputfile = "aks_sp.json"
$filecontent = $(az ad sp create-for-rbac --skip-assignment --name "${aks}_sp" --output json)
$Utf8NoBomEncoding = New-Object System.Text.UTF8Encoding $False
[System.IO.File]::WriteAllLines($outputfile, $filecontent, $Utf8NoBomEncoding)


#read the values from the json file
$aks_appid = $(jq -r ".appId" $outputfile)
$aks_secret = $(jq -r ".password" $outputfile)

"jq" is a bit peckish about file encoding so to make sure it is stored in a compatible format we can force it to UTF8. On my laptop VScode integrated shell stores it as UTF-16 LE when I just dump the az ad sp create-for-rbac with "> $outputfile"

With the service principal created and loaded into the variables using jq we can assign the role of Contributor to the virtual network. Notice also the UTF8 converting. While I've been testing I've found that jq is a bit peckish on how it likes it's files encoded. Utf8 works fine so the converter just forces that.

NOTE!
If you run all of this as a single script you will most likely receive an error that "Principal <guid> does not exist in the directory <guid>". A "small hack" is to let the script sleep for about 10 seconds to give AAD time to create the service principal. I haven't found any better way to do this yet so if anyone have a "wait-for-it" command that works with "az ad" commands let me know in the comments :)

#ZzzzZZz
Start-Sleep -s 10
az role assignment create --assignee $aks_appid --scope $vnetid --role Contributor

Now everything is set up and we can create the Azure Kubernetes Service. Another service that can be useful to deploy with AKS is a container registry. Especially when I use this as part of setting up a CI/CD

# optional create Azure Container Registry
az acr create --name $registry --resource-group $aksrg --sku basic

If you didn't create an ACR, remove the --attach-acr parameter. ACR can also be attached later.

NOTE!
This is a small cluster, with no autoscale and no real plan for networking. To create a production ready cluster you need a bit more planning around ip/network etc. Look at the network requirements on the Azure Doc and plan your networking using the Visual Subnet Calculator.

#create the aks service (remove linebreaks before running
az aks create --resource-group $aksrg \
       --name $aks \
       --attach-acr $registry \
       --node-count 3 \
       --network-plugin kubenet \
       --service-cidr $aks_srv_cidr \
       --dns-service-ip $aks_dns_ip \
       --pod-cidr $aks_pod_cidr \
       --docker-bridge-address $aks_docker_bridge \
       --vnet-subnet-id $akssnid \
       --service-principal $aks_appid \
       --client-secret $aks_secret

# get the aks resource id
$aks_resourceId = $(az aks show -n $aks -g $aksrg --query id -o tsv)
# wait for aks to be up and running
az resource wait --exists --ids $aks_resourceId

Now the cluster is up and running. To set the context for kubectl to your newly created cluster run.

az aks get-credentials --resource-group $aksrg --name $aks  --overwrite-existing

To verify that everything is up and running get the cluster info using kubectl

kubectl cluster-info

It is important to understand that this is not a service that is designed and secured for production so do spend more time customizing and add security, network and capacity planning before deploying anything for production.

When you are done, running two simple commands will remove everything we have created.

#cleanup
az group delete --name $aksrg --yes
az group delete --name "NetworkWatcherRG" --yes
az ad sp delete --id $aks_appid
Remove-Item –path $outputfile

To do this in bash should require minimal changes. All of the Azure CLI commands are cross platform equal.

Feel free to leave a comment if you have any optimization tips or feedback!

Free O'Reilly ebook about DevOps

Alexander Viken — Sat, 11 Jan 2020 14:29:51 +0000

Microsoft is giving the O'Reilly E-Book "Effective DevOps" away for free if you visit https://azure.microsoft.com/en-us/resources/effective-devops/

Read the e-book to learn more about:

The foundations and central four pillars of effective DevOps.
Tips for fostering collaboration, strong interpersonal relationships, and * affinity between teams.
How to select tools and workflows that support and strengthen your organization’s unique DevOps culture.
How to troubleshoot common problems and misunderstandings.
How successful organizations have handled their DevOps journeys.

The book is written by Jennifer Davis and Ryn Daniels

Beautiful software and infrastructure architecture

Alexander Viken — Sat, 11 Jan 2020 01:59:25 +0000

The last 2.5 years I’ve been working with design and development of an EdTech CMS/LMS for a major publishing house in Norway - Gyldendal Norsk Forlag. It's a huge system with 150+ content creators creating content on all subjects for the public school in Norway. From 1st to 10th. There is a lot of diversity between the needs for content for a 1st grade student class and a 10th grade class and in addition there is regulatory requirements from the government, and the need implement adaptability now and in the future. A dream job for any system and solution architect.

A little while ago I took a screenshot of the application from the Application Insights Application Map that looked like this

The architectural principle I designed this around is a “Choreographed Services Architecture” principle and seeing it in full blossom just makes me happy and smile.

Getting there was a roller coaster with feelings from euphoria to despair and everything in between, but seeing it – and knowing that it works from repository, through automated CI/CD pipeline to it’s API endpoints makes me happy. Seeing how well both Azure Service Fabric and Azure Kubernetes Services perform just makes me smile.

To create all this we used a multitude of services in Microsoft Azure Cloud (App Services, Functions, Data Lake, Storage, CosmosDb (SQL, Cassandra, Gremlin), DataBricks, Search, Service Fabric, Kubernetes Services, KeyVault, AAD, Network, VMSS, RBAC, NSG, ARM), Azure DevOps (Repositories, Pipelines, Artifacts), Docker, .NET Core 2.1, 2.2 (& 3.0), C#, Solr.

To create the frontend for the editors we applied a microservice mindset and developed a React solution based on “micro frontend” principles. We created an application that handled authentication and authorization and implemented a messaging infrastructure so that web app self-hosted web components could do their job based on the "master" application authentication and authorization rules. Each "plugin" or self hosted component could use security context and messaging/event subsystem to relay messages and events to other plugins.

This has by far been the most exciting software project I've ever been part of throughout my career. How often to you start in a new job to find out that the the whole self developed product portfolio is in such a bad shape that the technical debt alone would strangle any development department. And from that be given the mandate and opportunity design something new, from scratch based on modern architectural principles and technologies - with NO legacy code to worry about. Truly awesome.

You should learn to use Azure CLI! And use it with extensions

Alexander Viken — Fri, 10 Jan 2020 23:22:09 +0000

The x-plat Azure CLI command line tools are an extremely powerful toolbox you can use when it comes to deployment, querying and management of Azure resources. With the CLI you have command line access to a majority (most) of the services Azure provide.

I am still somewhat new to the Azure CLI and have veen a "hardcore fan" of PowerShell (the best command line tool available - that doesn't need grep to understand its command output) and Azure PowerShell. I've spent many hours with these cmdlets. First using ASM (Azure Service Manager) then with ARM and the AzureRM (Azure Resource Manager). I'm still a big fan of PowerShell. Tt's latest iteration, PowerShell Core, I think will be a strong contender to existing shells on any OS platform in the future.

Anyhow.... I digress, back on topic.

There is not much of a controversy saying that the winner of "best azure command line tool" is Azure CLI.
On traditional windows platforms the previous PowerShell AzureRM module has been replaced by the Az module to make it more aligned with Azure Cli in features but still..
It's biggest issue to date is that it is confined to Powershell while Azure CLI can be used in most (if not all) Linux/Mac shell environments including PowerShell Core and Windows PowerShell.

In the beginning, when I started learning the CLI syntax I found it confusing and not very intuitive at all. The traditional AzureRM (and Az)PowerShell command syntax felt much safer and easier to understand, I felt more human readable somehow. Over time I mastered the structure of CLI syntax and smile at how much more productive I have become using it.

Below is three examples on how you would use three simple commands, login to an account and list all resource groups in the default subscription and create a resource group in northeurope.

#Azure CLI

PS C:\tmp>az login
PS C:\tmp>az group list
PS C:\tmp>az group create -n "MyRg" -l "northeurope"

For the parameters -n(ame) and -l(ocation) you can decide yourself if you want to use the long or short version of the params.

PowerShell Az
PS C:\tmp>Login-AzAccount
PS C:\tmp>Get-AzResourceGroup
PS C:\tmp>New-AzResourceGroup -Name "MyRg" -Location "northeurope"

You don't need to write a lot of code to see that there is a definitive productivity boost in using the CLI, given that you have invested time in learning the syntax. In my opinion the CLI syntax is just as verbose as PowerShell Az is, shorter but smarter.

The absolute biggest argument for the CLI is it's cross shell/platform support, unlike PowerShell Az that requires a version of PowerShell. PowerShell Core runs on windows,linux and mac, but it's not always possible to install a full blown shell on a machine, and if you are a lifetime ninja of bash you should be able to use that if that is your preference. It is really nice to know that I can do my job no matter what computer OS i happen to have available, the syntax is the sam.

Talking about Bash.... If you are planning to write and run automation scripts against the Azure management apis from a workstation or server I would definitely consider installing PS Core. It's capabilities to work with objects and not just text that need to be grep'ed. I'd dread to do this in Bash

Get-AzResourceGroup | Select-Object -Expand $_ `
    | foreach-object -Process  { `
        Write-Host ("'{0}' has provisioning state '{1}' with unique id '{2}'" -f  `
                                                                        $_.ResourceGroupName, `
                                                                        $_.ProvisioningState, `
                                                                        $_.ResourceId )
}

PowerShell scripts can also work with Azure CLI, but it require a bit more work to to parse the command response and would look something like this.

$json = $(az group list --output json)|ConvertFrom-Json | Select-Object -Expand $_
$json | Select Id, Name | foreach-object -Process {
    $rg = $_.Name
    Write-Host "Resource Group: " $rg 
}

but both of the above script samples will run in any PowerShell console.

Finally, with the rapid evolution cloud services, enhancements and new services there is no way that the dev team that maintain the Azure CLI will be able to keep up. A really nice feature in the CLI is it's ability to use extensions to add capabilities. For instance it's not possible to work with Azure Firewalls with the default install package for CLi, but if you use

PS C:\tmp>az extension add --name azure-firewall

you will have the ability to create and manage firewalls through the console. To see a list of available extensions use the command

PS C:\tmp>az extension list-available --output json

A couple of my favorites are the "interactive" extension that gives you a much richer console window with intellisense. Still in preview but looks promising. the azure-devops extension lets you manage most parts of Azure DevOps pipelines, repos,projects and teams.

All in all I think that investing time to learn and having this command line syntax skill will make you a lot more productive. As a bonus you won't have to wait for all that javascript and HTML to finally load and render on the portal just because you clicked a wrong link... You also get more sensible feedback if you append --debug or --verbose to your commands.

happy command lining! :)

Tool to help you plan subnets in networks

Alexander Viken — Thu, 09 Jan 2020 01:44:31 +0000

It is important, when you're working with infrastructure design to have a good plan for the layout of the network!

A really good tool for this is one I came across through a friend of mine while "complaining" about lack of good network tools and setting up cloud infrastructure over a beer at my favorite "satellite office" Last Train in Oslo.

Visual Subnet Calculator has become one of the most valued tools I have in my toolbox when I work with cloud architecture and/or infrastructure. It is a simple, no fuss web app that lets you define a network, then start dividing and/or joining subnet addresses. It also has a feature that lets you store or share a direct link to the subnets you have created so it also can function as a network documentation.

Creating a IP map for any infrastructure project is core. The map will help you design a layout of your network and it's subnets, so that you'll later are able to determine where to deploy devices based on their needs and their context.

This is particularly important when you later plan to apply security to the infrastructure, or when you need to add or divide new subnets inside a network to ie. isolate devices or create custom routing rules between devices.

Thank you Rikard!

The beginners guide to Kubernetes in Azure

Alexander Viken — Fri, 03 Jan 2020 00:11:19 +0000

If you know some basics about what containers and what they are, and you want to take the next step and expand that into a more robust cloud hosted solution, your research and go-to solution will eventually land on Kubernetes. It has become more or less the standard for containerized application hosting these days.

Kubernetes (or k8s as it is often shortened to) can at first look a bit intimidating but it only looks that way. It is actually quite easy to understand if you sit down and learn the basics.

My preferred platform for running k8s clusters is Microsoft Azure since I already have around 10 years of experience with that environment from development, DevOps and architecture. K8s on the hand i've only worked with for about two years and it's been a road of trial and errors :) I was trying to learn k8s at the same time as Azure Kubernetes Services (AKS) was new, before it became GA and before you could do any customization to the hosting environment itself - kinda painful.

What I missed when I started was a really good "AKS for dummies" guide. A little late for me now, but not long ago i found just that in the Kubernetes Learning Path Microsoft published early 2019.

In it, it's a really good link to a youtube video guide that walk you through all the pieces of Kubernetes and how they work. I highly recommend it for anyone wanting to learn k8s even more if you plan to run your workload on Azure.