3 steps that help ensure ongoing success with Azure Terraform

· · , , , , , , , , , ,

Tagged: , , , , , , , , ,

Recently I’ve been working with individuals and organisations looking to adopt Terraform (and Infrastructure as Code in general), as part of their Azure strategy or ongoing Azure development. Whilst it’s fair to say this is unlikely to be an overnight process, and rather a process that will take time and development – there are lots of things that can help on the journey, and in this post I’ll be summarising 3 steps you can take to help on this learning journey, to ensure your success. These are applied directly to Azure Terraform, but the practices can be applied to wider IAC tools and processes – for example with Azure Bicep too. I’ve summarised these 3 as they are aspects that come up time and time again in my experience (and based on my own learning) – and hopefully these will prove helpful to others too.

Note – these are just 3 focus areas I have found to be helpful. Other resources and methods are available – as well as some awesome Microsoft and HashiCorp training, which I have linked to in the resources section of this post.

1. Community and Learning Resources

In my view, one of the best places to start out with Azure Terraform, is all of the awesome community and learning materials available. From guides to code, and videos to walkthroughs, there is a huge range of material available. It’s important to understand the basics when starting this journey – and in particular, around key security fundamentals for Azure Terraform, as there are obvious differences between what might be done in a lab environment, to what would be done in production for example.

Two key resources for starting the journey are those provided by Microsoft and HashiCorp themselves – and offer detailed overviews and guidance. Both of these are linked below:

Both of these resources provide very helpful information and guidance – running through key aspects and the basics that you’ll need for understanding, and getting started. One of the key aspects to ensure you understand is the concept of Providers. Providers are “…a logical abstraction of an upstream API. They are responsible for understanding API interactions and exposing resources.” (https://registry.terraform.io/browse/providers). What this means is that providers enable Terraform to communicate with various other platforms – AWS, Azure, GCP, etc. So for Azure, we are likely to be using some or all of the following providers:

Microsoft Learn - Provider Overview
Microsoft Learn – Provider Overview

There are also a range of  Community blogs, posts, and videos that can help you get started here – I’ve listed a few below:

2. Challenge Yourself!

Another key method that shouldn’t be overlooked, is that of a lab environment – whether this is provided via a Visual Studio Subscription, PAYG, or a Company Subscription for testing/labs etc, having a safe space to test things out and learn is really important. For myself, when learning Azure Terraform, getting hands on in safe environment (where the only damage I could do was use up my credit, or cause havoc with my own test resources!) was key.

If you work for a large organisation or Microsoft Partner, you may be able to get a Visual Studio Subscription, which includes a monthly credit allowance that you can use. See here for more details: https://azure.microsoft.com/en-us/pricing/member-offers/credit-for-visual-studio-subscribers. Note, for those working at Microsoft Partners – the Partner Portal allows the allocation of these.

Having environments to test with is also very useful too – and fortunately, there is a huge range of community maintained environments available that you can deploy, test, and tweak, all whilst learning. I found this was far more effective than just starting out with blank TF files and writing my own code!

Another utterly shameless plug here, but I have a range of environment that you can use for testing and learning, available on GitHub here: https://github.com/jakewalsh90/Terraform-Azure. Within this repo you’ll find a range of different environments, ranging from simple “Base Lab” environments (designed as small testing environments), all the way up to deployments of Virtual WAN for example. These are a great way to learn and deploy already written and tested code – which you can then practice tweaking and changing whilst you are learning.

My library full of samples and demo environments - great for learning more!
My library full of samples and demo environments – great for learning more!

Why not also set yourself a challenge?

Tweaking code others have written is a great way to learn – but there is also no substitute for writing code and building for yourself. This ensures hands on time and gets you into the code – which is important for learning. Setting a challenge in the style of a hackathon, can also be really helpful, and can be done with others or alone. Setting yourself a challenge based on real scenarios is also really helpful – perhaps you’ve worked on a project or design that wasn’t delivered using Azure Terraform, and wish to see if you can create it again using Terraform?

My Virtual WAN Demo environment was created to allow me to learn more about Virtual WAN.
My Virtual WAN Demo environment was created to allow me to learn more about Virtual WAN.

When I do this I usually start with a simple diagram – so I know what needs to be created, and then I’ll proceed to the Terraform code stage. Deploying as you progress is also helpful here – deploy the first few resources, then continue with your code, applying as you go (so you can see those changes taking effect). Remember to use the destroy command in between sessions though if you’re deploying any Resources that incur high cost – this will save you credit, and is another great example of the power of Terraform when it comes to deployment and cost effectiveness.

AI can also be really helpful here – GitHub Copilot can assist with writing Terraform. Check out this great post from Jack Roper on spacelift.io that covers this in more detail: https://spacelift.io/blog/github-copilot-terraform

3. Continue the journey

Continuation of learning, and awareness of changes, are also a key aspect of any Infrastructure as Code journey. Whilst some aspects may remain static – the changes we see in the supporting ecosystem need to be followed. What do I mean by this? Well – consider we have a basic Terraform deployment using the AzureRM Provider. There are two things we primarily need to consider here:

  • Changes and updates to Azure – this isn’t really any different to a normal Azure deployment, but we need to be aware of things like Services that are retired or changed, and ensure our code matches these (which is the same as if we had done a manual deployment).

Azure Updates will provide the details we need for this – and is something I’d recommend anyone working with Azure regularly visits:

  • Changes to the Providers we are using – this will be new to those new to Terraform, and depends largely on the providers that you are using with your deployment. In most cases, Azure deployments will use the AzureRM provider – which receives regular updates to cater for things new Azure Resource types and changes to the Azure platform. Over the last few months the AzureRM provider has been updated 2-3 times per month on average, so it’s important to keep up to date on these changes, particularly if you are deploying newer Azure services (e.g. those that have been recently released or have been changed or updated recently). See here for more details on the Provider updates via GitHub releases: https://github.com/hashicorp/terraform-provider-azurerm/releases.

Okay – enough about changes, what about learning more?

Learning beyond the basics is likely to lead to more complex deployments, using advanced functions, and development of aspects like modules for example. In many cases this part of your journey is likely to be unique – but below I’ve shared a few aspects I’ve been working with to develop beyond basic Azure Terraform:

Functions – these are a very powerful way to extend and enhance your code, with additional functionality and purpose. I’ve used these for things like calculating Subnets. This sounds simple but taking a single CIDR range as a variable and then using this throughout your code, whereby all the necessary ranges are calculated for you, can be a very powerful change and reduce the reliance on large amounts of variables for example. See here: https://github.com/jakewalsh90/Terraform-Azure/tree/main/CIDRHost-Demo. This is just a small example of how a single function (of many that are available) has helped – but you can read more about all of these here: https://developer.hashicorp.com/terraform/language/functions.

Modules – Modules are also a great way to develop your skills and usage of Terraform. Modules provide a way to create repeatable code, that can be used in numerous deployments, to ensure that Resources are deployed in a standardised way, again and again. Modules are most frequently used when we need to deploy using patterns – that provide standardisation and repeatability. Think of things like self-service deployment, standardisation, and reusability, which are all critical in a business environment. You can read more about Modules, and also find a guide to creating your first module here: https://developer.hashicorp.com/terraform/language/modules.  

Azure Verified Modules
Azure Verified Modules

Azure Verified Modules – As well as creating your own modules, there are also a range of verified modules, which are “an initiative to consolidate and set the standards for what a good Infrastructure-as-Code module looks like.” These provide curated and Microsoft maintained modules that can be used to deploy both Resource and Pattern modules, in a scalable and maintained fashion – you can ready more about these here: https://azure.github.io/Azure-Verified-Modules/.

Resources:

Skip to content