Brett Miller

Making Sense of Azure Functions Routes

2022-03-15T00:00:00+00:00

When you initialise a new HTTP trigger function using the Azure Functions CLI, you are prompted for the name for your function. This name is used for the folder within your project but also the name of the function itself. There are also some default configuration settings for the URI that will be used when you publish your FunctionApp.

Route Prefixes

When you create Azure Functions project which has HTTP endpoints all function routes by default are prefixed with api e.g. myFunctionProject/api/<functionName>. This is fine for most cases, but it can be confusing as it is not very descriptive.

You can however customise this URI route within your Azure Functions project so that it can be more useful.

Changing the Route Prefix

Within your PowerShell Azure Functions project you have a host.json file which contains the settings for your Functions project.

Full docs on the host.json file can be found here: host.json reference for Azure Functions 2.x and later.

You can customize or remove the prefix using the extensions.http.routePrefix property in the host.json file.

Below is an example of how to remove the route prefix from your functions by setting the routePrefix property to an empty string:

{
  "extensions": {
    "http": {
      "routePrefix": ""
    }
  }
}

Given that there is no real need to have a pre-defined route prefix I tend to do this on most of my projects to make the URI’s easier to read and distinguish from each other, especially when there are multiple functions within the project.

Changing the Route of your Functions

Now that you have removed the routePrefix from your host.json file, you also have the option to customise your functions route on a per function basis.

Below is an example of how to change the route for a specific function by setting the route property in the function.json file:

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ],
      "route": "descriptiveFunctionName"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    }
  ]
}

This allows you greater control over the URI for your function and makes it more descriptive.

If I start a local debug of a basic HTTP function you can see the changes you have made to the route prefix and function route:

Before:

After:

Why does it really matter?!

In this contrived example there’s no real need to change the route prefix or the function route but if you have a project which has multiple functions with similar names you may want to change the route to group specific functions together.

For example you could have multiple functions within your project and you want to define the route to coincide with the METHOD of the HTTP request for each function.

Conclusion

This blog post shows you some of the basic changes you can make to the route prefix and function route within your Azure Functions project.

There are some other cool things that you can do with routes within your functions projects which I will cover in a follow up post soon.

Multiple GitHub Account Management

2022-02-21T00:00:00+00:00

If you have multiple github accounts then you will very quickly become aware of an annoyance of having to manage your git config for each repository. If you don’t want to commit as the account configured in your global .gitconfig then you have to remember to set your username and email on each repository that you clone or create.

If you don’t become aware of this then you will quickly be searching StackOverflow for how to amend the last commit author.

Use a personal gitconfig

The way I have been managing this is by using the includeIf section within my .gitconfig file and if the path of the repository is in my personal projects directory to include an alternative gitconfig.

# If Path is personal projects then use personal gitconfig
# The /i makes the path case insensitive
[includeIf "gitdir/i:C://git/personal/"]
	path = ~/.gitconfig-personal

This tells git that if you’re directory is in the path defined in gitdir then to use the .gitconfig-personal file instead of the usual config file.

In your .gitconfig-personal folder add your personal details.

[user]
    name = Brett Miller
    email = brett@millerb.co.uk

The Downside

Using this method does not work so well if, like me, you use different SSH keys for accessing the two accounts then you also need to use an ssh config and when you clone a repository you have to change the URL e.g. when I clone a personal repository I have to change the remote URL to personal.github.com.

❯❯ cat ~/.ssh/config

# Github Personal account
  Host personal.github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_personal

# Github Work account
  Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_work

An Even Easier Way

So I stumbled upon a blog post a little while ago which showed an easier way to do this resulting in no longer requiring a different gitconfig for personal configuration. I have just changed workstations so decided that I would configure this properly.

After searching for about an hour for the blog post I finally found it or at least something that covered what I was looking for).

This uses the same includeIf that I was using before but makes it even easier!

❯ cat ~/.gitconfig
[user]
    name = Brett Miller
    email = brett.miller@work.com

[core]
    sshCommand = "ssh -i ~/.ssh/id_rsa_work"

[init]
    defaultBranch = main

[includeIf "gitdir/i:C:/git/personal/"]
    [user]
        email = brett.miller@millerb.co.uk

    [core]
        sshCommand = "ssh -i ~/.ssh/id_personal"

This uses the core.sshCommand setting to specify my personal SSH key if I am within a git project in my personal directory.

Summary

I used to use SSH authentication for work and HTTPS for personal projects. When I changed laptops a while ago I switched to SSH for both accounts. Now that GitHub have deprecated the use of basic authentication for HTTPS auth, it makes SSH more appealing

Really pleased with this configuration as it has eliminated the need for an ssh config, a secondary gitconfig, I no longer have to change the remote repository URL or set user and email per repostory.

Now to figure out GPG signing on a per account basis 🙌

Secret Santa Generator

2021-11-25T00:00:00+00:00

This year I was designated to organise secret santa for the family 🎅

Naturally I opted to be a total nerd about it and use PowerShell to randomly generate who would be gifting presents.

Ho Ho Ho

I started out knowing the list of people taking part, even if they didn’t know they were participating at the time and I would just randomly assign them someone to buy a present for……simple right?!

Define a list of names

# Names changed to protect the innocent
$names = @(
    'Jeff',
    'Maria',
    'Veronica',
    'Wolfgang',
    'Francisco',
    'Persephone',
    'Meryl',
    'Jerry'
)

Loop over the names and assign a santa and who they are buying for

foreach ($person in $names) {
    # Looping through the list of names and make sure a person can't be their own secret santa
    $buyingFor = $names | Where-Object { $_ -ne $person } | Get-Random -Count 1
    
    # Print out the name of the person and the name of the person they are buying for
    '{0} is buying for {1}' -f $person, $buyingFor

    # Remove the person from the list so they can't be chosen again
    $names = $names | Where-Object { $_ -ne $buyingFor }
}

The downside to this is that every now and then there was an issue with the last person in the loop would sometimes not have anyone to buy for. I wonder if I could fix it so that I was last in the list 🤔

Jeff is buying for Wolfgang
Maria is buying for Francisco
Veronica is buying for Persephone
Wolfgang is buying for Meryl
Francisco is buying for Maria
Persephone is buying for Jeff
Meryl is buying for Veronica
Jerry is buying for 🙃

To Google

This wasn’t as easy as my ‘Quick PowerShell script’ idea initially planned so naturally I did what any engineer would do!

I googled powershell secret santa

The first result was from Mike F. Robbins (@mikefrobbins) naturally and it looked perfect for what I was trying to do.

Mike’s blog post: https://mikefrobbins.com/2017/12/21/generate-a-secret-santa-list-with-powershell/

Interestingly he encountered the same issue I did with the basic loop sometimes leaving a santa without someone to gift a present to. I decided to steal Mike’s code to make my life easier.

Mike’s Secret Santa Function

I’ve removed the comment based help for brevity.

function Get-MrSecretSantaList {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory)]
        [ValidateCount(2,32768)]
        [string[]]$Name
    )
    if ($Name.Length % 2 -ne 0) {
        Throw 'An even number of Names must be specified in order for matching to occur.'
    }
    do {
        $Giftee = $Name | Sort-Object {Get-Random}
    }
    while (
        $(for ($i = 0; $i -lt ($Name.Length); $i += 1) {
            if ($Name[$i] -eq $Giftee[$i]) {
                Write-Verbose -Message "A duplicate has occured in loop $i Name: $($Name[$i]) cannot match Giftee: $($Giftee[$i])"
                $true
                break
            }
        })
    )
    for ($i = 0; $i -lt ($Name.Length); $i += 1) {
        [pscustomobject]@{
            Gifter = $Name[$i]
            Giftee = $Giftee[$i]
        }
    }
}

This works great but with only one problem! I am in the secret santa so I don’t want to know who other people are buying for, including me! So i will have to change it up a little.

Modified solution

The main changes are in the latter part of the function which generates the output. I don’t want to print to the screen and spoil the surprise so I decided I would write the results to a file so that I could send the file to people without opening it and revealing who the recipients of the gift were.

function Get-MrSecretSantaList {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory)]
        [ValidateCount(2,32768)]
        [string[]]$Name
    )
    if ($Name.Length % 2 -ne 0) {
        Throw 'An even number of Names must be specified in order for matching to occur.'
    }
    do {
        $Giftee = $Name | Sort-Object {Get-Random}
    }
    while (
        $(for ($i = 0; $i -lt ($Name.Length); $i += 1) {
            if ($Name[$i] -eq $Giftee[$i]) {
                Write-Verbose -Message "A duplicate has occured in loop $i Name: $($Name[$i]) cannot match Giftee: $($Giftee[$i])"
                $true
                break
            }
        })
    )
    for ($i = 0; $i -lt ($Name.Length); $i += 1) {
        # Create a file name of the Secret Santa
        $fileName = '{0}.txt' -f $Name[$i]
    
        # Generate a file name of the Secret Santa with the persons name.
        # GetUnresolvedProviderPathFromPsPath will add the files to the $PWD
        $outputPath = Join-Path -Path $PSCmdlet.GetUnresolvedProviderPathFromPSPath('.') -ChildPath $fileName
    
        # Add a line of text to tell Santa who they are gifting the present to.
        $fileValue = 'Your buying for {0}' -f $Giftee[$i]
        Set-Content -Path $outputPath -Value $fileValue
    }
}

Outcome

This was the quickest way I could think of that would generate a secret santa for everyone without me, the organiser, knowing who was gifting presents to whom. I then sent the individual files to each participant so that only they knew who they were gifting a present to.

Parsing Docker Output with jq

2021-11-23T00:00:00+00:00

There was a question that came up in the PowerShell discord last week which was an interesting question which ended up with 3 entirely different answers from different people which is interesting to see how different people approach a problem.

Goal!

The goal is to get a list of images from docker images command and delete them with docker rmi

More than one way to cook an egg

Shane O’Neill (@Shaneis) went for the -split operator and some regex to obtain the Name

❯❯ $d = docker ps -a
❯❯ $d[1..$d.Count] | ForEach-Object -Process {
>>     [PSCustomObject]@{
>>         Name = ($_ -split '\s{2,}')[-1]
>>     }
>> }

Name
----
ecstatic_chandrasekhar
modest_colden
confident_newton
charming_ganguly
infallible_bassi

Jos Koelewijn (@jawz_84) resorted to using ConvertFrom-StringData which converts string output into a hashtable so you can access the key/value pairs.

❯❯ docker images | Select-Object -Skip 1 | ConvertFrom-StringData -Delimiter ' ' | ForEach-Object Keys
vsc-socialopinions-d9e1feb0b3c073836b87b223deef5934
vsc-azureadfunction-fddb75b17c14d953fe380384c6a1553f
vsc-hacktoberfestscot-e2763e33d037a0d4346af8af7577007a
vsc-stucco-6fc12c4e758f0f1744dacf9375502cd2
vsc-stuccotest-17e1b8eb5a6cf01465f888a61c8384fa
vsc-stuccofix-5998915b92e138a5f4d7cd7c3d3af669

My PowerShell comfort blanket 🛌

PowerShell makes it so easy to perform data manipulation that you very rarely have to use anything else.

I knew that docker had JSON output so I just had the command output the format and use ConvertFrom-Json. Using jq and --slurp formats individual JSON objects into a large array.

docker container ls --all --format '{{json .}}' | jq --slurp | ConvertFrom-Json | Select-Object -Property names

What about a bit further outside of my comfort zone and not relying on PowerShell? Docker allows you to provide a filter for your format to only return specific properties.

docker container ls --all --format '{{.Names}}'

And what about using just jq?

You can use the .[] object iterator to return only the properties you want.

docker container ls --all --format '{{json .}}' | jq '.Names'

Or again using slurp and only selecting the property you require.

docker container ls --all --format '{{json .}}' | jq --slurp '.[] | .Names'

Conclusion

There are many ways to achieve the same thing and people will generally tackle a problem in the way they’re most comfortable with.

I’ve found over the years that having small amounts of familiarity with different tool sets outside of my normal wheelhouse is beneficial for those moments that you may not have your normal toolset available to you.

Whilst I may have skirted around the goal of removing the containers once you are able to parse the output it can be utilised however you see fit.

git add –patch - Selectively track changes within a file

2021-11-16T00:00:00+00:00

If there is one thing I have learned whilst using git is that you never really stop learning git!

Scenario

I am working on fixing something in a project and whilst doing so I notice something else which needs to be fixed. Now I could go and raise an issue against the repo to remind myself that it needs to be fixed, alternatively I could add a TODO in the code and there are extensions which track that for you.

Or if you’re really clever you can fix it straight away and utilise git to selectively track changes within the file.

git add

Normally working on a change within a project, you will make and save the changes in your file then using git add you will add the changes you just made to your index.

# Add all local changes to your index
git add .

git commit -m "Made a super awesome change"

You can be more selective than this by only commiting certain files so you can chunk changes across multiple files into different commits.

# Only add changes to a specific file to your index
git add MyProject/subFolder/file.ps1

git add –patch

You can go one step further utilising git add --patch which allows you to add specific changes within the same file to different commits.

Using this blog post for example.

❯❯ git status -u
On branch master
Your branch is up to date with 'origin/master'.

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	_posts/2021/11/2021-11-16-git-add-patch.md

nothing added to commit but untracked files present (use "git add" to track)

I can choose to add different parts of the file to the index so that I can make my commits smaller and easier to track within the git history.

❯❯ git add --patch _posts/2021/11/2021-11-16-git-add-patch.md

@@ -17,4 +17,6 @@

 <!--more-->

+### git add
+Normally working on a change within a project....etc

(1/3) Stage this hunk [y,n,q,a,d,j,J,g,/,e,?]?

Git will show you a diff information about where the code is in the file, followed by the diff (hunk) of code that it has selectively chosen for you. This is followed by the number of hunks and some interactive options for adding code to the index.

Typing ? will show help for the interactive options. I’ve only listed the simple ones here:

y - stage this hunk
n - do not stage this hunk
q - quit; do not stage this hunk or any of the remaining ones
d - do not stage this hunk or any of the later hunks in the file
s - split the current hunk into smaller hunks
? - print help

Once you have selected the hunks you want to add you will commit your changes with a relevant commit message

❯❯ git commit -m "Added first 2 hunks from patch"
[gitAddPatch 4f998ba] Added first 2 hunks from patch
 1 file changed, 29 insertions(+)
 create mode 100644 _posts/2021/11/2021-11-16-git-add-patch.md

You’ll notice that running git status again will still show the file still has untracked changes which is the remaining hunk that we didn’t add to the index.

❯❯ git status
On branch gitAddPatch
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   _posts/2021/11/2021-11-16-git-add-patch.md

You can then add the rest of the file to your index with a final git add . and a meaningful commit message.

* b23195b - (HEAD -> gitAddPatch) Added rest of changes to file (24 seconds ago) <Brett Miller>
* 4f998ba - Added first 2 hunks from patch (3 minutes ago) <Brett Miller>

Conclusion

Git as a utility is massive and I’ve definitely only scratched the surface of what it can do. Learning these little tips and tricks save me significant time and effort whilst working on projects.

This came in handy recently when I had some parameters that I was changing during testing and I wanted to commit changes to the code but not the minor changes to the parameters that I was using for testing. I was able to fix another bug and patch the change to the file as a separate commit so that I could keep my git history clean and have it reviewed as a different pull request.

Making The Switch to MacOS

2020-07-10T00:00:00+00:00

WARNING! - Long Post Alert…..Again.

I previously wrote a post on this which was very popular as I tried to document all of my productivity hacks and shortcuts that I use on a daily basis to assist in writing PowerShell. That post is My VSCode Setup.

I have since moved from a Windows laptop to MacOS so I wanted to make a note of customisations and changes so I had a place to track all of them but other people may also find some of them handy.

Some stuff won’t have changed too much because, well…..there was no need but my way of working has shifted slightly and I spend more time with a split terminal between bash and PowerShell.

I thought the switch to MacOS was going to be more difficult than it initially was but once I sorted my muscle memory out (mainly for copy and paste) it was a pretty seamless transition. The multiple desktops and the trackpad/gestures is an awesome experience.

Unfortunately I do have to keep an Azure VM handy for the very odd ocassion that I may need something Windows specific.

Homebrew
Terminal -lt iterm2
- Setting zsh as the default shell
Customisations/Tweaks
Oh My Zsh
Profile
- Bash / zshrc profile
- Powershell Profile
Remote Development Extension
JQ
Other Things

Homebrew

Switching from Windows where I used Chocolatey for my software installation needs, I had heard about homebrew and was keen to make a start with using a decent package manager from the start.

You can install homebrew from the command line too!

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

Now that you have Homebrew installed you can go about installing the rest of your applications.

For reference:

❯❯ brew list -1                     ❯❯ brew cask list -1
azure-cli                           azure-data-studio
gdbm                                discord
ncurses                             firefox
openssl                             insomnia
openssl@1.1                         iterm2
pcre                                keepassxc
python                              microsoft-azure-storage-explorer
python@3.8                          microsoft-edge-beta
readline                            microsoft-remote-desktop-beta
sqlite                              obs
xz                                  powershell-preview
zsh                                 sizeup
zsh-completions                     slack
                                    spotify
                                    spotmenu
                                    visual-studio-code-insiders
                                    zoomus

Terminal -lt iterm2

So rather than use the standard built in terminal that comes pre-installed with MacOS I have opted to use iterm2 (mainly because I heard other people say that it was awesome and no other reason) and I love it.

It supports pretty much anything you can throw at it in terms of fonts, customisations and themes.

Setting zsh as the default shell

chsh -s /bin/zsh

Customisations/Tweaks

I seen a gist from @markwragg which I bookmarked with the anticipation that I may one day switch to MacOS then unknowingly I made that switch my self. He documented some of the changes that he made when he switched to MacOS. That gist is here and has some handy stuff within.

I chose not to make as many changes as Mark but the ones I blatantly stole are:

Make the dock appear faster when using auto hide

I have my notification bar and dock hidden on my mac for maximum screen real estate so this helps when quickly trying to access the dock.

defaults write com.apple.dock autohide-delay -float 0
killall dock

Enable Case Insensitve Autocomplete

Case insensitive auto-complete is a total life saver coming from the windows world and I don’t know how many hours I have lost on linux machines debugging my own stupidity.

echo "set completion-ignore-case On" >> ~/.inputrc

iterm2 Keyboard Shortcuts

Pressing ESC to clear the whole line in the terminal which is familiar behaviour for me and one of the muscle memory options that I want to keep. The rest of my keyboard shortcuts are listed below (that I can remember adding).

iTerm2 > Preferences > Profiles > Keys

Key Combination	Action	Wassat?
ESC	Send Hex Codes 0x15	Clears the current line
⌥ Backspace	Send Hex Codes: 0x17	BackwardKillWord
⌥ <-	Send Escape Sequence b	BackwardWord
⌥ ->	Send Escape Sequence f	ForwardWord
⌥ Shift <-	Move Start of Selection Back -> Move by Word	Select BackwardWord
⌥ Shift ->	Move End of Selection Forward -> Move by Word	Select ForwardWord

There are probably more but these are the ones I can remember adding.

Oh My Zsh

Oh My Zsh is a delightful, open source, community-driven framework for managing your Zsh configuration. It comes bundled with thousands of helpful functions, helpers, plugins & themes.

Profile

This has changed slightly as I am now on MacOS in the fact that I am now running two different profiles for bash/zsh and one for PowerShell.

Bash / zshrc profile

I am using PowerLevel9k for my theme which offers some nice customisations. I have not really played around with this beyond my initial setup which I am quite happy with.

I am now finding that I am using zsh as a primary shell over PowerShell for day to day interaction especially when interacting with git. I also tend to stick to bash for Azure CLI too for the tab completion and speed it offers.

I have added this as a gist.

There are a few things that I have had to add to make my life easier when switching between bash/zsh and PowerShell so that I have consistent commands available to me.

cls is too engrained and quicker to type so that has to go in there. The other two aliases are pretty self-explanatory.

# aliases
alias cls='clear'
alias code='code-insiders'
alias pwsh='pwsh-preview'

The other thing that I really like is the tab completion for Azure CLI which doesn’t appear to work with zsh out of the box. Adding this to your zshrc profile enables that.

# Azure CLI tab completion
autoload bashcompinit && bashcompinit
source $ZSH/oh-my-zsh.sh
source /usr/local/etc/bash_completion.d/az

Powershell Profile

Update After a thread on twitter by Dave Carroll I decided to take a little time and fix up my pwsh profile to something a bit nicer.

This has changed a little since I moved. Mainly to accommodate differences between bash and PowerShell on Mac so that they work in a consistent manner.

My Toolbox module that I import in my profile can be found here in my github repo. This has the following functions which are imported into my session.

# Module with some helper functions
Import-Module -Name Toolbox

Backup-Profile.ps1                 # Backs up my profile to github
Export-AzKeyVaultCertificate.ps1   # Export Azure Key Vault PFX Certificate
Get-CommandInfo.ps1                # Stolen from Chris Dent 😃
Get-Gituser.ps1                    # Shows the current folders git user from gitconfig
Get-MultiPass.ps1                  # Windows only CliXml Command to import Credentials object
Get-Syntax.ps1                     # Reformatting of Get-Command $Command -Syntax to print vertically
New-MultiPass.ps1                  # Windows only CliXml Command to create Credenials object

I like being able to traverse the directory structures quickly so these shortcuts allow me to jump back one or two directories quickly and are also available in zsh so it’s consistent behaviour across shells.

# functions to be aliased to make traversing directories consistent with zsh shortcuts
function BackOne {
    Set-Location ..
}
function BackTwo {
    Set-Location ../..
}

zsh has some handy default parameters for ls so I have added these to my PowerShell prompt as I am too used to ls to stop using it so may as well make it consistent right?!

function Get-NativeChildItem {
    & (Get-Command ls -CommandType Application) -lhG
}
function Get-NativeChildItemG {
    & (Get-Command ls -CommandType Application) -G
}
function Get-NativeChildItemA {
    & (Get-Command ls -CommandType Application) -lAhG
}

Alias all of the things

New-Alias -Name code -Value 'code-insiders'
New-Alias -Name '..' -Value 'BackOne'
New-Alias -Name '...' -Value 'BackTwo'
New-Alias -Name ll -Value Get-NativeChildItem
New-Alias -Name ls -Value Get-NativeChildItemG
New-Alias -Name la -Value Get-NativeChildItemA
# clip on windows is clip.exe and I use this a lot.
New-Alias -Name clip -Value Set-Clipboard

PSReadline is awesome and it’s made even more awesome on MacOS with the PSUnixUtilCompleters PowerShell module by @rjmholt which gives you parameter completers for native linux and MacOS comands.

Enable this in your profile with the below:

Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward

# Menu Complete for tab completion is really nice and gives you parameter information during selection.
Set-PSReadLineKeyHandler -Key Tab -Function MenuComplete
Set-PSReadLineOption -HistorySearchCursorMovesToEnd:$true

After seeing Tyler Leonhardt (@TylerLeonhardt) example in the twitter thread I decided to give Posh-Git a go with Oh-My-Posh and I am very pleased with the result.

Git auto-completion
VCS status in my prompt
Easy customisation
Consistent Powerlevel theme between zsh and PS

Import-Module posh-git
Import-Module oh-my-posh
$gitpromptsettings.DefaultPromptAbbreviateHomeDirectory = $true
$GitPromptSettings.DefaultPromptSuffix = $('`n❯❯ ' * ($nestedPromptLevel + 1))

# This is to prevent an issue where iterm2 throws an error every time the prompt is run
if ($env:LC_TERMINAL -eq "iTerm2") {
    $ThemeSettings.Options.ConsoleTitle = $false
}

Set-Theme Powerlevel10k-Lean
$ThemeSettings.CurrentUser = $null
$ThemeSettings.PromptSymbols['promptindicator'] = ("`n{0} " -f ([char]::ConvertFromUtf32(0x276F) * 2))

One other cool thing that I added to my profile recently was enabling the ability to traverse folders without having to use Set-Location or cd which is consistent behaviour with zsh.

I found an old blog post on devblogs where Jason Shirk(@lzybkr) had written how to do this so I modified it slightly for my needs so that any command you type is evaluated and if it’s a path it will traverse into that directory. This is yet more consistency between the two shells and saves on the typing. Coupled with the .. & ... aliases it makes navigation so pleasant.

# Taken from here: https://devblogs.microsoft.com/scripting/whats-in-your-powershell-profile-powershell-team-favorites/
# Changing directories without having to type cd to replicate zsh
$ExecutionContext.InvokeCommand.CommandNotFoundAction = {
    param([string]$commandName,
        [System.Management.Automation.CommandLookupEventArgs]$eventArgs
    )
    # Remove the ‘get-‘ prefix that confuses Test-Path after we produce
    # something that is path like after the get-.

    if ($commandName.StartsWith(‘get-‘)) {
        $commandName = $commandName.Substring(4)
    }  

    # If the command looks like a location, just switch to that directory
    if (Test-Path -Path $commandName) {
        $eventArgs.CommandScriptBlock = { Set-Location -LiteralPath $commandName }.GetNewClosure()
        return
    }
}

I have updated the gist of my profile here.

Remote Development Extension

I wrote about Developing Pwsh Azure Functions inside a Container some time ago and it was really my my first foray into using docker as a daily tool but this is now how I work every day for most of the repositories and code that I write.

The above post covers pretty much everything you need to get started with that but using docker as a development enviroment has been a game changer.

I use Azure functions a lot, both PowerShell and C# and being able to develop these in a container without having to have the Az Functions Core tools or npm or any of the extensions installed locally is a dream. You need to check it out if you haven’t already.

JQ

So I have written already about how I use AzureCLI & PowerShell together but I was also made aware of jq which I suppose is similar to how I would normally use ConvertFrom-Json or ConvertFrom-Json.

I have been trying to get better with this instead of just defaulting to PowerShell but the data manipulation and objects that Pwsh provides it’s a tough ask.

Other Things

My original post is still very much valid and most of the shortcuts I have copied over and work just fine.

Some of the items are now available by default in VSCode or in the PowerShell Extension but some of them I will never be able to live without.

I will attempt to add to this post when I make additions or substractions to my setup but this is a good start

Azure CLI vs Azure PowerShell - Why not both?

2019-12-07T00:00:00+00:00

I see quite a bit of conversation about whether people prefer Azure CLI or PowerShell for managing their Azure resources and if like me, you have come from managing on-premises workloads before moving over to managing cloud magic, you will likely want to use the tools that are familiar to you. So naturally I tend to lean towards PowerShell but I have been using the CLI more frequently so I wanted to highlight that it doesn’t have to be one or the other.

The Azure PowerShell module is now on it’s 3rd iteration. You had the original Azure module followed by AzureRM and now you have the cross platform Az module.

The Azure CLI, if you’re used to powershell, is not very familiar syntax wise, it has very limited tab completion and the more in depth you go you have to start referencing the docs for things like JMESPath query language.

As engineers I think it is natural to look at how we can manage cloud workloads with with the skills and tools that we already have but what if we’re missing out and what if you have no choice but to adopt something else?

Learning a new CLI can take time and when frustration sets in it’s easy to think about going back to your PowerShell comfort blanket.

What if these tools are easier to use?

What if they are better? 😱

Personally I find Az CLI really performant and the built-in help is really concise. It shows mandatory parameters as well as examples and it covers a good 98% of what I need when I am working at the command line in the console.

Azure CLI ‘vs’ PowerShell 🥊

Naturally after working with PowerShell for quite some time you become accustomed to it’s Object output, however when you first start playing with Azure CLI you suddenly start getting raw JSON, which if you’re returning more than one resource is going to fill your screen and be difficult to read.

Azure CLI does however offer different output formats (Output Docs)

output	Description
json	JSON string. This setting is the default.
jsonc	Colorized JSON.
yaml	YAML, a machine-readable alternative to JSON.
table	ASCII table with keys as column headings.
tsv	Tab-separated values, with no keys

The downside is when you start looking at wanting anything other than the default properties when using table or tsv output then you have to starting googling the JMESPath syntax or digging through examples to get what you want. This is where the frustation sets in as you already know how to do this with PowerShell.

Lets have a look at the different ways to retrieve some results using Azure Cli and PowerShell.

Az CLI Query

Let’s list all of the FunctionApp’s available in the current account. We want to change the resourceGroup property to resource because I needed a contrived example and we also want the name and defaultHostName properties.

az functionapp list --query "[].{resource:resourceGroup, name:name, defaultHostName:defaultHostName}" -o table

Resource    Name          DefaultHostName
----------  ---------     ---------------------------
poshbotio   poshbotio     poshbotio.azurewebsites.net
Myfunction  MyFunction    myfunction.azurewebsites.net
Functest    HttpFunction  httpfunction.azurewebsites.net

✅ Azure CLI is available X-Plat including in Cloud Shell.

❌ JMESPAth is unfamiliar syntax, all of the braces are not very nice to type.

Native PowerShell

Using the PowerShell cmdlets to retrieve exactly the same. We have to use a calculated property to change the resource property. Get all of the results and select the properties you want with Select-Object

Get-AzFunctionApp | Select-Object @{n='resource';e={$_.resourceGroup}}, name, defaultHostName

Resource    Name          DefaultHostName
----------  ---------     ---------------------------
poshbotio   poshbotio     poshbotio.azurewebsites.net
Myfunction  MyFunction    myfunction.azurewebsites.net
Functest    HttpFunction  httpfunction.azurewebsites.net

✅ Available X-Plat including in Cloud Shell.

✅ Familiar PowerShell syntax, Calculated Properties are familiar but still a bit meh.

❌ FunctionApp cmdlets are only available in the preview Az.Functions module to date.

Hybrid Az Cli & PowerShell

Using a combination of the two. Retreive the results with Azure CLI in raw JSON, then convert it to a powerShell object with ConvertFrom-Json and use the familar Select-Object syntax. Performant and familiar.

az functionapp list | ConvertFrom-Json | select-Object @{n='resource';e={$_.resourceGroup}}, name, defaultHostName

Resource    Name          DefaultHostName
----------  ---------     ---------------------------
poshbotio   poshbotio     poshbotio.azurewebsites.net
Myfunction  MyFunction    myfunction.azurewebsites.net
Functest    HttpFunction  httpfunction.azurewebsites.net

✅ Available Cross Platform including in Cloud Shell.

✅ No need to install extra PowerShell modules.

✅ Basic Az CLI knowledge required so good discoverability.

✅ Familiar syntax for consuming and manipulating the output with PowerShell.

Deciding which to use

I don’t really have a preference between Azure CLI and PowerShell but if you look at the output above you get exactly the same result using all three methods.

I do tend to lean towards the hybrid of the two as it is familiar to me without having to learn the nuances of JMESPath query filters but also gives me the flexibility of being able to pipeline that object into other PowerShell command or a Export-* cmdlet.

Azure CLI Built-In Help

I always brag about how amazing the PowerShell help system is for people learning PowerShell but I also think that the team who built the Azure CLI have done an amazing job on the builtin help.

Typing az -h will show you the extensions available to be used.

❯❯ az -h

Group
    az

Subgroups:
    account               : Manage Azure subscription information.
    acr                   : Manage private registries with Azure Container Registries.
    ad                    : Manage Azure Active Directory Graph entities needed for Role Based
                            Access Control.
    advisor               : Manage Azure Advisor.
    aks                   : Manage Azure Kubernetes Services.
    ams         [Preview] : Manage Azure Media Services resources.
    apim        [Preview] : Manage Azure API Management services.
    appconfig   [Preview] : Manage App Configurations.
    appservice            : Manage App Service plans.
    backup      [Preview] : Manage Azure Backups.
:

To find out more about the usage of these extensions you can use az {subGroup} -h

az functionapp -h

Drilling down further

az functionpp list -h

It lists examples with each use of the help switch and lists the available sub-groups, commands and examples

Az Find for Examples and Discoverability

I didn’t know this existed until recently but it’s an awesome tool for discoverability at the command line when using Az CLI.

Here is what the help says about the command

Command
    az find : I'm an AI robot, my advice is based on our Azure documentation as well as the usage patterns of Azure CLI and Azure ARM users. Using me improves Azure products and documentation.

And here is what it says about the examples we have been using. This can be really helpful when you’re getting used to the Azure CLI but also if you’re just unsure about how a specific command should work

❯❯ az find "az functionapp list"
Finding examples...

Here are the most common ways to use [az functionapp list]:

List default host name and state for all function apps.
az functionapp list --query ".{hostName: defaultHostName, state: state}"

List all running function apps.
az functionapp list --query ""

List available locations for running function apps.
az functionapp list-consumption-locations

Summary

Find what works for you. The cloud is a big magical place where people are doing amazing things, with this comes a variety of new tools for managing all aspects of the cloud.

I’ve found a hybrid pattern that works for me when I am using the console for discoverability or information gathering. It gives me the speed of the Azure CLI with the familiar syntax of PowerShell so I can be productive without having to learn an entire new command line tool.

Try not to build something just for the sake of building something. The PowerShell community is definitely guilty of building a tool just because it suits our needs. Take a look at what is already out there and maybe think about contributing to that instead, that way an entire ecosystem benefits from your take on it.

The more that I use the Azure CLI, the more I am inclined to just dive in and use it, it is available in both bash and PowerShell on my Mac & in cloud shell in browser so I can just fire it up without having to think about it.

Developing PowerShell Azure Functions Locally in a Container

2019-11-27T00:00:00+00:00

I have recently just switched work machines from a Windows laptop to a Macbook. I’ve not had much exposure to anything other than Windows but I live on the command line most of the time and 'mac' -eq 'linux' anyway right?

Keeping My Machine Tidy

Part of this switch I made it my mission to try and keep my machine as tidy as possible and with that I didn’t want to immediately go and install a load of stuff that I was then going to have to manage and update…..especially when i only needed some of it for specific projects.

I have been spending a considerable amount of my down time watching people do live coding on twitch and in particular Michael Jolley (Twitter) and I was particularly intrigued by him showing how he develops inside of docker containers so I decided to give it a try.

Pre-Requisites

The installation requirements for Azure Functions are on docs.microsoft.com.

On both Mac and Windows this requires the Azure Functions Extension Bundle or the .NET SDK and on Windows you’ll have to install npm and node.js so not having to install anything locally is good.

Setting up your Workspace

Create a folder on your machine that you want to contain your project.

PS > New-Item -ItemType Directory -Name MyFirstFunction

    Directory: /Users/brett.miller/git/gitpersonal

UnixMode   User           Group       LastWriteTime   Size Name
--------   ----           -----       -------------   ---- ----
drwxr-xr-x brett.miller            27/11/2019 16:03     64 MyFirstFunction

Open that folder in VSCode

PS > cd MyFirstFunction

PS > code .

Once you’re inside Visual Studio Code you can open your folder in a container by using the command pallette.

F1 > Remote-Containers: Open Folder In Container

Select the folder you want to open. You will then be presented with the list of available containers from within the extension.

What you will notice however is that there are options for Azure Functions with C#, Java, Node & Python but there is no container for PowerShell Azure Functions. WTF?!

Well I have fixed that by opening a Pull Request and adding a container definition which has all of the dependencies required. This is pending release at the time of writing.

To get access to these prior to release you can grab what you need directly from the Github Repo.

Open your folder in VSCode and create another folder called .devcontainer then create two files, devcontainer.json & Dockerfile.

Copy the contents of the two files from github to their corresponding files on your machine.

Now you can reopen the folder in your container with Remote-Containers: Reopen in Container.

This may take a while as docker now needs to download the necessary image and work through the docker file installing dependencies so that all tools are available. Subsequent runs should not take as long as it will reuse the image it creates.

Once it has finished building the docker file it will open a terminal defaulting to PowerShell.

You can confirm this with $PSVersionTable

PS /> $PSVersionTable

Name                           Value
----                           -----
PSVersion                      6.2.3
PSEdition                      Core
GitCommitId                    6.2.3
OS                             Linux 4.9.184-linuxkit #1 SMP Tue Jul 2 22:58:16 UTC 2019
Platform                       Unix
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0…}
PSRemotingProtocolVersion      2.3
SerializationVersion           1.1.0.1
WSManStackVersion              3.0

Now that you have your folder opened in a container with all of the necessary tools you can start initialising your Function Project.

To see how to do that you can follow this post I created to get you started:

PowerShell & Azure Functions - Part 1

2019-11-27T00:00:00+00:00

I have been using Azure Functions for a little while and I published my initial thoughts on Azure Functions and their use cases here.

In this post I want to cover how to get started with Functions and a few lessons learned and I wanted to collect together the documentation I used to get up and running which at present lives in various places on the Microsoft Docs site.

What are Azure Functions

Simply put they are a serverless solution in Azure which allow you to run code without having to worry about where it is running or maintaining the underlying infrastructure.

You can read a whole lot more about Azure Functions in the documentation and it can explain a lot better than I can.

Writing Your First Function
- Pre-Requisites
- Create A Local Function Project
Function Layout Overview
- Scaffolding
- Your Function - The Fun Stuff
Running & Debugging Your Function
Summary
What’s Next?
References & Links

Writing Your First Function

I will go over how to write an Azure Function using Visual Studio Code as that is by the best development experience

Pre-Requisites

You can find the pre-requisites and installation instructions in the Microsoft Docs.

PowerShell 6+
Visual Studio Code (obviously)
Node.js which includes npm
Azure Functions Core Tools
.NET Core SDK - I have this installed but you can avoid that with the extension bundles

You can also use the Remote Development Extension and containers to run and debug your functions but there is no official docker image for PowerShell available. I have however created a post to show you how to build your own.

Developing PowerShell Azure Functions In Docker And VsCode

Create A Local Function Project

Create a folder where your Function will be contained

New-Item -ItemType Directory -Name MyFirstFunction

cd MyFirstFunction

Now that you’re in your project folder initialise your function. Select PowerShell from the list and it will

PS /root/MyFirstFunction> func init

Select a worker runtime:
dotnet
node
python 
powershell

Choose option: 4
powershell

Writing profile.ps1
Writing requirements.psd1
Writing .gitignore
Writing host.json
Writing local.settings.json
Writing /root/MyFirstFunction/.vscode/extensions.json

You then need to create your first PowerShell function within your initialised folder and select the trigger type.

PS /root/MyFirstFunction> func new

Select a template:
1. Azure Blob Storage trigger
2. Azure Cosmos DB trigger
3. Azure Event Grid trigger
4. Azure Event Hub trigger
5. HTTP trigger
6. IoT Hub (Event Hub)
7. Azure Queue Storage trigger
8. SendGrid
9. Azure Service Bus Queue trigger
10. Azure Service Bus Topic trigger
11. Timer trigger

Choose option: 5
HTTP trigger

Function name: [HttpTrigger] HttpTriggerFunction
Writing /root/MyFirstFunction/MyFirstFunction/run.ps1
Writing /root/MyFirstFunction/MyFirstFunction/function.json
The function "MyFirstFunction" was created successfully from the "HTTP trigger" template.

Your folder structure will now have a sub-folder with the name you gave to your function.

Directory: /root/MyFirstFunction

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----          11/26/19  4:26 PM                HttpTriggerFunction
------          11/26/19  4:26 PM             72 host.json
------          11/26/19  4:26 PM            142 local.settings.json
------          11/26/19  4:26 PM            882 profile.ps1
------          11/26/19  4:26 PM            273 requirements.psd1

Your first PowerShell Azure Function is ready to play with 😁

# Open the current folder in VSCode
code .

Function Layout Overview

Scaffolding

The majority of the contents of the folder are used to assist with deploying and configuring of your Function.

.gitignore
- This is a templated gitignore file which contains the common files which you don’t want to commit to git. Things like local.settings.json which is used for storing secrets for local debugging.
host.json
- This is for setting global configuration settings for your functions. There are lots of options to configure there but not much you have to worry about at first. Host.json reference documentation is here and covers all of the possible options.
local.settings.json
- When running and debugging your function locally, app settings are read from the local.settings.json file. The possible settings for local development are covered in this article.
profile.ps1
- this is only required if your function is going to require authentication for interaction with other Azure resources within your tenant. The comments in the file are self-explanatory.
requirements.psd1
- This is specified to manage your dependencies and the host will automatically download dependencies from the PowerShell Gallery for you so you don’t have to ship modules with your code. It is recommended to pin to a specific major version of a module to prevent breaking changes. Dependency Management Docs

Your Function - The Fun Stuff

Within your HttpTriggerFunction folder you have your actual code file and information about bindings for this particular function.

function.json
- This is where your binding information and parameters are defined. You may need to modify these if you’re using something like Azure Service Bus Queue trigger. Triggers & Bindings Docs
run.ps1
- This is the powershell code that makes up your function and where you will spend most of your time.
- It consists of a param block where content is passed into your function, the main body which interacts with the content, and an output which utilises an Azure Functions specific cmdlet called Push-OutputBinding for passing content back out of your function. Push-Outputbinding Docs

Running & Debugging Your Function

One of the best things about developing Azure Functions in Visual Studio Code is the fact that all of the tools that you need to write, test, debug and deploy your Azure Function is available to you out of the box.

Running Your Function Locally

You can check that your function works as intended locally with the Function Core Tools. The local runtime is the same runtime that hosts your function app in Azure so it saves a tonne of time having to redeploy to test minor changes.

To run your function locally navigate to your function project folder and start the runtime.

PS /root/MyFirstFunction> func start

                  %%%%%%
                 %%%%%%
            @   %%%%%%    @
          @@   %%%%%%      @@
       @@@    %%%%%%%%%%%    @@@
     @@      %%%%%%%%%%        @@
       @@         %%%%       @@
         @@      %%%       @@
           @@    %%      @@
                %%
                %

Azure Functions Core Tools (2.7.1846 Commit hash: 458c671341fda1c52bd46e1aa8943cb26e467830)
Function Runtime Version: 2.0.12858.0
Skipping 'FUNCTIONS_WORKER_RUNTIME' from local settings as it's already defined in current environment variables.

Hosting environment: Production
Content root path: /root/MyFirstFunction
Now listening on: http://0.0.0.0:7071
Application started. Press Ctrl+C to shut down.

Http Functions:

        HttpTriggerFunction: [GET,POST] http://localhost:7071/api/HttpTriggerFunction

Alongside from pretty trick ASCII art you get some information about your Function Runtime, the address and port the host is listening on, the methods your function supports and the URI that you can use to trigger the function.

Any logs from the function are then output to the console so if you need to see what is happening within your code you can use the age old tactic of littering it with output.

[11/27/19 2:24:11 PM] INFORMATION: PowerShell HTTP trigger function processed a request.

Triggering your Function

You can open the URI in your browser which will trigger the function and you should see the output below.

You can see from the output that this is the else block of the code telling you to provide a query parameter to your function.

If you change the URI to http://127.0.0.1:7071/api/HttpTriggerFunction?name=brett you will get the following output.

Testing this in the browser is fine when your Azure Function supports GET method but in order to test a POST method then you will need to use PowerShell or Postman so you can pass a JSON payload.

Azure Functions Methods

So if you’ve used PowerShell to interact with API’s then you’ll likely be aware of the HTTP Methods that are used for RESTful services. It’s the same principle for Azure Functions and you should take this into account when designing your Functions as the way you handle your input parameters will differ.

When your function is triggered with the GET method then the Query property of your $Request payload will be populated but if the POST method is used then the Body property will be used.

The methods are defined in the function.json and because the example project has both GET and POST then it checks for each of the properties accordingly

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    }
  ]
}

# Check to see if the payload has a query value - GET method
$name = $Request.Query.Name

# If query is not populated then check the Body value - POST method
if (-not $name) {
    $name = $Request.Body.Name
}

Summary

Working with PowerShell in Azure Functions has been an awesome experience. Being able to develop and run them locally without having to constantly push my changes to Azure made the learning process so easy.

The way you work with Functions is very familiar so you can bring what you already know about writing a PowerShell Function and with very little modification, start working with your cloud workloads in a much leaner way. Something that would previously have been a scheduled script in Azure Automation can now be reactive and if you’re on a consumption plan then it will cost nothing at all.

One of the most difficult parts of getting to grips with Azure Functions in general is the sheer amount of documentation that resides on slightly different pages dependent on what information you’re looking for. It was very easy to overlook parts of the documentation or quite frequently had to piece together parts from the examples in other programming languages as PowerShell documentation within Azure Functions is lacking a little.

What’s Next?

I have another follow up post in the making which will cover local debugging, deploying your function and some more in depth parts of PowerShell in Azure Functions as well as some of the edge cases I encountered.

References & Links

Azure Functions - Event Driven, Serverless Functions

2019-11-26T00:00:00+00:00

I’ve been spending a signficant amount of time developing and playing with PowerShell for Azure Functions since they were V1 and they were not as good as they could have been.

Fortunately they have been in V2 for quite some time and went to General Availability as of Ignite in November ‘19. This means that they can “officially” be used for production workloads with official support.

Drawing a distinction between other Azure Offerings

So my initial reaction when I started playing with PowerShell in Azure Functions was that they were so much nicer to work with than Azure Automation but the more I played with them, the more I realisd that they were NOT a direct replacement but an accompaniment.

Azure Automation is still very useful for automation and long running tasks such as reports and Azure Functions really shine when you want event driven actions.

Event Driven - Say What?!

Events in Azure can mean a number of things and 9 times out of 10 the first Azure Function you will create is an HTTP trigger which is a manual interaction. As you delve deeper you start seeing situations where event driven is at the forefront of what you want to react to.

Example Scenario

Azure Key Vault Secret monitoring. This has been in private preview for a while and is still in public preview (Read the docs here).

Key Vault integration with Event Grid is currently in preview. It allows users to be notified when the status of a secret stored in key vault has changed. A status change is defined as a secret that is about to expire (within 30 days of expiration), a secret that has expired, or a secret that has a new version available. Notifications for all three secret types (key, certificate, and secret) are supported.

With access to the private preview I setup a test Key Vault with some secrets that had various expiry dates. When the secrets approached expiry there was an event posted to Event Grid. I created an Azure Function which subscribed to this event and sent a notification to Slack to notify that there was a secret about to expire.

The initial evolution of this was to trigger an Azure DevOps pipeline and renew a Let’s Encrypt certificate then release a product in a staging environment with an automatically updated certificate.

Integration With Other Azure Services

Azure Functions has first class support for integration with other services and at time of writing this there are numerous triggers and bindings that can be utilised as part of an Azure Functions. List can be found here and the number of services are growing.

This means that you can be reactive to any events that are raisd from your infrastructure in Azure.

An Azure IaaS VM is created Event can trigger a Function to automatically tag that VM
Someone adds an image to blob storage. Azure Function is triggered and uploads that image to congnitive services API and reports back on sentiment analysis for a face in the image.

The options are astounding.

Summary

In my humble, and often incorrect, opinion I think that Azure Functions with PowerShell is a match made in heaven for Ops people. Being able to setup automation that automatically reacts to events raised in such a seameless way opens up a new world of managing infrastructure at scale and the cost is pennies.

I will follow this post up with some additional content around lessons learned and developing Az Functions that hopefully you will get some use out of.