Courses & Labs

Get certified through the AZ-900 exam by learning Microsoft Azure cloud fundamentals and core services.

Learn Azure AI with Microsoft Foundry and prepare for the AI-901 certification exam (replaces retired AI-900).

Design, build, and optimize Azure solutions using the Well-Architected Framework pillars.

Learn practical Microsoft 365 workflows for productivity and collaboration in enterprise environments.

Hands-on lab: deploy a web application to Azure App Service, configure deployment slots, manage scaling settings, and monitor app health.

Hands-on lab: create and deploy serverless functions on Azure, configure triggers, bindings, and integrate with other Azure services.

Hands-on lab: create an API Management instance, import APIs, configure products and policies, and publish to a developer portal.

Hands-on lab: apply inbound and outbound policies in Azure API Management to secure, throttle, and transform API requests and responses.

Hands-on lab: build a Docker container image, push it to Azure Container Registry, and automate deployment via a GitHub Actions CI/CD pipeline.

Hands-on lab: deploy and manage a RESTful API on Azure App Service, configure routing, and monitor API performance.

Hands-on lab: create and publish API versions and revisions in Azure API Management to manage breaking and non-breaking changes.

Hands-on lab: configure and customise the Azure API Management developer portal for publishing APIs and engaging API consumers.

Hands-on lab: enable static website hosting on Azure Blob Storage and deploy web assets using the Azure CLI.

Hands-on lab: create an Azure Function that reads and writes data to Azure Table Storage for a scalable NoSQL backend.

Hands-on lab: deploy a containerized web application that connects to an Azure SQL Database, configure connection strings and firewall rules.

Hands-on lab: configure Azure Backup policies for virtual machines, trigger on-demand backups, and restore VM data from a recovery point.

Hands-on lab: provision an Azure Bastion host and use it to securely connect to virtual machines without exposing public IP addresses.

Hands-on lab: create and manage deployment slots in Azure App Service using the Azure CLI, and perform slot swaps for zero-downtime releases.

Hands-on lab: generate shared access signatures (SAS) and stored access policies to control delegated access to Azure Blob Storage.

Hands-on lab: create an Azure Event Grid topic, configure subscriptions, and build an event-driven architecture to react to Azure resource changes.

Hands-on lab: write a Bicep template to declaratively provision an Azure App Service and Azure SQL Database as infrastructure as code.

Hands-on lab: configure soft delete, versioning, and lifecycle management in Azure Blob Storage to protect and recover data.

Hands-on lab: create an Azure Stream Analytics job that reads from Event Hubs, runs real-time queries, and outputs processed data.

Hands-on lab: configure partition keys and parallelism in Azure Stream Analytics to optimise throughput for high-volume data streams.

Hands-on lab: connect to SQL Server with multiple tools, run T-SQL for DDL/DML tasks, and explore SQL Server objects and services.

Hands-on lab: deploy workloads on Azure VMs and App Service, then compare management, scaling, and operational differences.

Hands-on lab: build a reusable Bicep module pattern with parameters and outputs to consistently provision Azure infrastructure across environments.

Operate elastic Azure VM workloads with VM Scale Sets and Application Gateway. Configure health probes, validate scaling events, and troubleshoot unhealthy instances.

Hands-on lab: inspect a Bicep repository, preview changes with what-if, deploy an approved IaC update, and verify Azure resource configuration.

Hands-on lab: launch Azure Cloud Shell, set subscription context, run Azure CLI commands, and complete a basic administrative workflow on Azure resources.

Hands-on lab: trace an Azure access path from DNS through the load balancer and backend health, use effective NSG rules and routes to isolate the failure, apply the minimum fix, and re-test.

Evaluate cloud infrastructure readiness for generative AI workloads in enterprise environments.

Understand and mitigate hallucinations in generative AI systems with retrieval-augmented approaches.

Build reliable AI agents with practical patterns for production enterprise deployments.

Practical prompt engineering techniques for IT administrators working with enterprise AI tools.

Secure Gen AI integrations against prompt injection, data disclosure, and agentic risks using the OWASP LLM Top 10 and hands-on mitigation techniques.

Implement function calling and tool use patterns with OpenAI APIs for production applications.

Build multimodal AI applications using OpenAI APIs for text, image, and combined inputs.

Hands-on lab: navigate the Azure Machine Learning workspace, create compute resources, and manage datasets and experiments via the Azure Portal.

Hands-on lab: use the Azure CLI and ML extension to manage Azure Machine Learning workspaces, compute clusters, and data assets.

Hands-on lab: register datastores, create and version data assets, and connect Azure ML to storage services for model training.

Hands-on lab: use Azure Automated ML to train and evaluate multiple model types, then deploy the best-performing model.

Hands-on lab: build a no-code regression pipeline in Azure ML Designer to predict weather conditions using drag-and-drop components.

Hands-on lab: train a classification model without writing code using Azure Automated ML, evaluate results, and review model explanations.

Hands-on lab: apply clustering algorithms in Azure Machine Learning to identify and visualise patterns in weather data.

Understand GitHub Copilot data flows and architecture for secure enterprise adoption.

Boost software development productivity with ChatGPT and advanced prompt engineering techniques.

Get started with Claude Code for AI-assisted software development workflows.

Configure Claude Code for team workflows with security rules and shared project settings.

Use Claude AI to streamline project management tasks and team coordination workflows.

Hands-on lab: implement OpenAI function calling to let a language model invoke external APIs and return structured, tool-augmented responses.

Hands-on lab: implement retry logic, error handling, logging, and rate-limit management for production-ready OpenAI API integrations.

Hands-on lab: use LangChain components — models, prompts, and output parsers — to build an automated weather report generator.

Hands-on lab: compose LangChain chains using LCEL syntax to build a conversational application with memory and streaming support.

Hands-on lab: expose a LangChain chain as a REST API using LangServe, enabling HTTP-based invocation of LLM-powered endpoints.

Hands-on lab: design few-shot prompt templates in LangChain to guide an LLM to produce consistent, example-driven weather summaries.

Hands-on lab: craft effective prompts by applying directions, output format constraints, and few-shot examples to get reliable LLM responses.

Hands-on lab: use LangChain output parsers with Pydantic models to enforce structured, type-safe JSON outputs from language models.

Hands-on lab: integrate LangChain function calling tools to dynamically invoke external weather APIs based on LLM reasoning.

Hands-on lab: apply the Least-to-Most prompting technique to break complex weather queries into smaller sub-problems solved sequentially by an LLM.

Hands-on lab: use few-shot prompting to guide an LLM in generating concise, structured summaries from weather text data.

Add OpenAI Codex to your daily developer workflow. Learn to migrate an OpenAI API integration, iterate on a UI with the in-app browser, and finish scoped Slack-initiated tasks with Codex.

Prepare for the KCNA exam with Kubernetes, containers, and cloud native fundamentals.

Hands-on Kubernetes application development labs to prepare for the CKAD certification.

Implement backup and disaster recovery strategies for Azure Kubernetes Service clusters.

Learn to implement GitOps workflows for reliable, automated Kubernetes application deployments.

Scale GitOps practices across large engineering organizations with proven enterprise patterns.

Build modern development workflows using Google Antigravity for cloud native teams.

Hands-on lab: write a Dockerfile to containerize a web application, build the image, and run it as a Docker container.

Hands-on lab: push Docker images to Docker Hub, pull and run containers, and manage image tags and repositories.

Hands-on lab: deploy a private Docker registry, push and pull images, and manage access to container images.

Hands-on lab: configure authentication for a private Docker registry using TLS and basic auth to restrict access.

Hands-on lab: pull and run the Azure SQL Edge Docker image, connect to the database, and execute SQL queries inside a container.

Hands-on lab: make changes inside a running Docker container and commit those changes to create a new reusable image.

Hands-on lab: tag Docker images with version labels, push multiple versions to Docker Hub, and manage image lifecycle.

Hands-on lab: write a multi-stage Dockerfile for a .NET application to separate build and runtime layers for smaller, secure images.

Hands-on lab: define and run a private Docker registry using Docker Compose for a repeatable, multi-service container setup.

Hands-on lab: reduce Docker image size and improve build performance for a .NET application using multi-stage build techniques.

Hands-on lab: run Microsoft SQL Server inside a Docker container, connect to the database, and manage data using SQL commands.

Hands-on lab: define a multi-service application using Docker Compose, manage container lifecycle, networking, and volumes.

Hands-on lab: create a Kubernetes Deployment and Service to deploy and expose a containerized application within a cluster.

Hands-on lab: author a Kubernetes Deployment YAML manifest, configure replicas, resource requests, and labels for a weather application.

Hands-on lab: create ReplicaSets to run multiple Pod replicas, test self-healing, and scale workloads up and down.

Hands-on lab: perform rolling updates to a Deployment, monitor rollout status, and roll back to a previous revision on failure.

Hands-on lab: implement a blue/green deployment strategy in Kubernetes to release new versions with zero downtime.

Hands-on lab: deploy a new application version to a subset of traffic using a Kubernetes canary strategy, then gradually roll it out.

Hands-on lab: install and manage a pre-built Helm chart in a Kubernetes cluster, configure values, and upgrade the release.

Hands-on lab: author a custom Helm chart using Go templates, define configurable values, and deploy the chart to a Kubernetes cluster.

Hands-on lab: configure liveness, readiness, and startup probes in Kubernetes Pods to enable automatic health monitoring and recovery.

Hands-on lab: set CPU and memory requests and limits on Kubernetes Pods to control scheduling and prevent resource contention.

Hands-on lab: use Kustomize to manage environment-specific Kubernetes configurations without duplicating YAML manifests.

Hands-on lab: define ResourceQuota objects in Kubernetes namespaces to enforce compute and object count limits across teams.

Hands-on lab: create and consume ConfigMaps in Kubernetes Pods via environment variables and volume mounts to externalise configuration.

Hands-on lab: create Kubernetes Secrets, inject them into Pods as environment variables or mounted files, and manage sensitive configuration securely.

Hands-on lab: create Kubernetes Roles, ClusterRoles, and RoleBindings to enforce least-privilege access control for application workloads.

Hands-on lab: provision PersistentVolumes and PersistentVolumeClaims in Kubernetes to provide durable storage for stateful workloads.

Hands-on lab: diagnose and resolve common Kubernetes application failures using kubectl commands, logs, events, and describe output.

Hands-on lab: install the Metrics Server in a Kubernetes cluster and use kubectl top to monitor CPU and memory usage of Pods and nodes.

Hands-on lab: design multi-container Pod patterns (sidecar, ambassador, init containers) to enable co-located helper processes in Kubernetes.

Hands-on lab: create ClusterIP, NodePort, and LoadBalancer Services in Kubernetes to expose application Pods with different networking scopes.

Hands-on lab: define Kubernetes NetworkPolicy resources to restrict ingress and egress traffic between Pods for network segmentation.

Hands-on lab: deploy an Ingress controller in Kubernetes and configure Ingress rules for path-based and host-based traffic routing.

Hands-on lab: deploy and manage Kubernetes workloads with Deployments, including scaling, rolling updates, and troubleshooting.

Hands-on lab: deploy and manage a Kubernetes application using GitOps principles and Argo CD.

Hands-on lab: view Terraform state, detect drift, import unmanaged resources, and reconcile configuration inconsistencies.

Hands-on lab: configure Terraform providers, apply version constraints, inspect lock files, and set up provider aliases.

Hands-on lab: use Terraform input variables, expressions, and outputs to build reusable, environment-driven infrastructure.

Hands-on lab: refactor Terraform configurations with moved blocks to rename and reorganize resources without destructive changes.

Hands-on lab: provision a multi-tier VPC network topology and manage infrastructure through the Terraform workflow.

Hands-on lab: build and validate an Azure Kubernetes Service baseline cluster following best practices, including network configuration, security policies, and monitoring setup.

Hands-on lab: make direct API Server requests with kubectl and curl, apply labels to manage workloads, and configure pod probes and init containers.

Hands-on lab: create a Helm chart, install and validate an existing chart, host charts in a private repository, and manage dependencies between charts.

Hands-on lab: initialize a Kubernetes cluster with kubeadm, apply Flannel, deploy and expose nginx with NodePort, and verify access from the control plane node.