The AKS masterclass repository is a course syllabus you can read from the directory listing

Twenty-five directories, one per module

This repository is the code that goes with a course, not a library or a tool. The README is titled Azure Kubernetes Service with Azure DevOps and Terraform, links to the course page on stacksimplify.com, and then lists the modules.

The repository layout mirrors that list exactly. There is a 00-Pre-requisites directory, then 01-Create-AKS-Cluster, 02-Docker-Fundamentals, 03-Kubernetes-Fundamentals-with-kubectl, 04-Kubernetes-Fundamentals-with-YAML, 05-Azure-Disks-for-AKS-Storage, 06-Azure-MySQL-Flexible-for-AKS-Storage, 07-Kubernetes-Secrets, 08-Azure-Files-for-AKS-Storage, and the ingress modules from 09 through 14 covering the basics, context path based routing, delegating a domain from AWS Route 53 to Azure DNS, ExternalDNS with Azure DNS zones, domain name based routing, and SSL with Let's Encrypt.

After that come requests and limits, namespaces in three flavours, Azure Virtual Nodes, Azure Container Registry, Azure DevOps with AKS, the HTTP Application Routing add-on, Azure AD authentication with Kubernetes RBAC, autoscaling with both the cluster autoscaler and the horizontal pod autoscaler, production grade cluster design using the AKS CLI, provisioning with Terraform, and a final module on Terraform with Azure DevOps.

Reading that list tells you the shape of the lessons: it starts at the portal and ends at infrastructure as code with a delivery pipeline, and it deliberately teaches the same subject twice, once imperatively with kubectl and once declaratively with YAML.

The primary language recorded for the repository is HCL, which reflects where the course ends up rather than where it starts.

The curriculum arc, from kubectl to Terraform

The pedagogical structure is visible in the module numbering, and it is worth reading as a sequence rather than a list.

The early modules are the Kubernetes core. Module 3 is fundamentals with kubectl and module 4 is the same ground with YAML, which is a pairing that makes a point the course is clearly making: imperative commands are for exploring, manifests are for shipping. Modules 5, 6 and 8 then give AKS its three storage stories, Azure Disks, Azure MySQL Flexible and Azure Files, with sub-modules on custom storage classes and on the AKS default storage class, each with persistent volume and persistent volume claim examples, plus a user management web application deployed on MySQL through those claims.

The middle of the course is networking and identity. Ingress basics come first, then context path routing, then the domain delegation and ExternalDNS modules, then TLS. Requests, limits and namespaces follow, with namespace sub-modules for limit range and resource quota. Virtual Nodes and Azure Container Registry come next, including pulling images with a service principal and running them on virtual nodes.

The last third is delivery and automation. Azure DevOps build and release pipelines, cluster authentication with Azure AD and RBAC for both namespaced roles and cluster roles, access to multiple clusters, autoscaling, then the production grade cluster design built with the AKS CLI, and finally Terraform for provisioning and Terraform with Azure DevOps on top.

For an engineer, the value of the sequence is that the later modules depend on the earlier ones. The Terraform module assumes you already have the CLI and YAML grounding, and the DevOps module assumes you have a registry to push to.

Two reference tables that work as a checklist

Two tables in the README work as coverage checklists, and they are more useful to a reader than the module titles alone.

The Azure services table lists 21 services the course touches: AKS, Azure Disks, Azure Files, Azure MySQL Database, Azure Storage Accounts, Azure Cloud Shell, Azure Load Balancer, Azure DNS Zones, Azure Container Registries with and without a service principal, Azure DevOps build and release pipelines with ACR and GitHub repositories, Azure Public IP Address, Azure Standard Load Balancer, Azure Virtual Networks, Azure Active Directory, Azure Container Instances for virtual nodes, AKS Windows and Linux node pools, Managed Service Identity, Virtual Machine Scale Sets, and Log Analytics workspaces for Azure Monitor.

The Kubernetes concepts table lists 31 topics: architecture, Pods, ReplicaSets, Deployments, the four Service flavours including Load Balancer, Cluster IP, External Name and Ingress, ingress with SSL and redirect, ExternalDNS, domain name based routing, imperative versus declarative work, secrets, init containers, requests and limits, namespaces with limit range and resource quota, storage classes, persistent volumes, persistent volume claims, annotations, the horizontal pod autoscaler, the cluster autoscaler, config maps, RBAC at both role and cluster role level, Virtual Kubelet, and image pull secrets.

Two omissions are as informative as the entries. There is no network policy module and no service mesh, and there is no GitOps. For someone learning AKS as it is sold and certified today, that tells you what this course does not cover.

Sample applications and images you can pull

The course ships working software rather than empty manifests, which is what makes the repository useful outside the video.

There is a list of Docker images on Docker Hub under the stacksimplify organisation, including stacksimplify/kubenginx at versions 1.0.0 through 4.0.0, stacksimplify/kube-helloworld at 1.0.0 for a Spring Boot hello world API, stacksimplify/kube-frontend-nginx, stacksimplify/kube-nginxapp1 and kube-nginxapp2, and stacksimplify/kube-usermgmt-webapp tagged 1.0.0-MySQLDB for the user management application with MySQL storage.

The second table shows the images you are expected to build yourself and push to Azure Container Registry, with the repository placeholders left as YOUR_ACR_REPO.azurecr.io and paths like app1/kube-nginx-acr:v1 and app2/acr-app2:v1, and a third entry using a BUILDID tag for a custom build. Those placeholders are deliberate, since the point of those modules is the push and pull rather than a fixed image.

The sample applications listed are the nginx applications and the user management web application built with Spring Boot on MySQL, and there is a dedicated azure-aks-usermgmt-webapp-demo directory at the root for that one.

Two root level artefacts are worth knowing about. git-deploy.sh sits next to the README as a helper for pushing the sample applications, and a ppt-presentation directory holds the slides.

Terraform and Azure DevOps are the two closing modules

The final modules are where the course stops teaching Kubernetes and starts teaching delivery, and they are also the modules most likely to have aged.

Module 24 is provisioning AKS with Terraform, and its sub-modules are Terraform command basics, Terraform language basics, provisioning an AKS cluster with Terraform, creating Linux and Windows node pools that way, and creating an AKS cluster with a custom virtual network. Module 25 puts Terraform and Azure DevOps together.

The reason to look at these two modules first is that infrastructure as code for AKS has changed shape since the course was recorded. The module titles refer to creating the cluster and the node pools as separate steps, and the Azure CLI module in 23 is likewise written around the az aks create command with its many arguments rather than around a declarative model. Whether those commands are still the recommended path is a question to check against current Microsoft documentation rather than against the repository.

The DevOps side is described in the module titles too: build and push a Docker image to ACR, then build, push and deploy to AKS, then a starter pipeline and release pipelines. The Azure services table names the specific pipeline types, build pipelines with ACR and GitHub repositories, and release pipelines with AKS.

What the course does not do here is any GitOps or declarative deployment tool. The delivery story is entirely pipeline based, which was the norm when it was written.

Backup directories and change notes tell you how the course ages

The repository listing contains something you rarely see in a published repository: a set of dated backup directories, and that is the clearest signal of how this course is maintained.

There are BACKUP-BEFORE-AUGUST2025, BACKUP-BEFORE-JULY2022-UPDATES, BACKUP-BEFORE-JULY2025-UPDATES, BACKUP-BEFORE-JUNE2024-UPDATES and BACKUP-BEFORE-OCT2024. Beside them sit two change notes, 2023-December-Changes.md and 2024-June-Changes.md.

Read together, they describe a course that is revised in batches rather than continuously. When the Azure services or the CLI change, the author snapshots the old files under a dated backup directory and updates the live module directories, and a change note records what moved. The result is a repository where the same module exists in several historical states.

That is useful for a learner, because the change notes are where you find out that a module was rewritten and why. It is also a caution for anyone tempted to lift code from it. A directory that matches the module you are reading may not be the directory that matches the documentation.

The last push to the default branch was on 2026-10-20, and there are no tagged releases, so there is no version to reference. The licence field for the repository records no licence, which for a directory of course content is a reasonable choice but does mean you should not assume permission to reuse it in a commercial project.

Editorial conclusion

Adopt this repository as a study map if you are preparing for the Azure AKS certification path or need a worked example of each Azure Kubernetes Service feature, since the module sequence and the ready-made sample applications save you from assembling your own. Do not adopt it as production infrastructure or as a reference for current Azure practice, because it is course content with no recorded licence, dated backup directories and module code that reflects the Azure CLI syntax of its time. Before you build on any of it, read the change notes at the repository root, because the December 2023 and June 2024 files exist precisely to tell you what shifted, and check the module directory for the feature you need against the current Microsoft documentation.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. stacksimplify/azure-aks-kubernetes-masterclass on GitHub