Azure Kubernetes Service with Azure DevOps and Terraform

discover azure kubernetes service (aks) as a highly available, secure, fully managed platform across 36 regions, supporting windows and linux workloads; learn its high-level architecture and node pools.

Create an AKS cluster in Azure, connect with Azure Cloud Shell and kubectl, explore resources, install Azure CLI, deploy a simple app, and configure node pools and networking.

Connect to the AKS cluster via Azure Cloud Shell, configure kubectl credentials, verify client and server versions, and explore namespaces, nodes, and core resources with kubectl.

Install and configure the Azure CLI and AKS CLI on your local desktop to deploy kube manifests to an AKS cluster using kubectl, fetch credentials, and verify nodes.

Deploy a sample nginx application to an AKS cluster using kubectl, expose it with a load balancer, and test access via the public IP while reviewing core Kubernetes concepts.

Explore Docker fundamentals, from what Docker is and its architecture to installation on Windows and Mac, troubleshooting, pulling and running images, building custom images, and essential commands.

Discover how Docker solves traditional infrastructure problems by packaging apps into containers and using consistent Docker images across environments, guided by Docker concepts such as daemon, containers, and registry.

Explore Docker architecture, including the Docker daemon, Docker client, images, containers, networks, volumes, and registries, and learn to pull, run, build, and push images to Docker Hub or private registries.

Learn to install Docker Engine and Docker Desktop on Windows and Mac, meet system requirements, test with docker run hello world, and resolve macOS keychain credential issues.

Pull a docker image from Docker Hub, login, pull, and run it as a container with port mapping 80:8080 and a named app1; verify, access localhost/hello, and manage start/stop/remove.

Build a custom nginx docker image from a Dockerfile and index.html, run it locally, and test the result, then tag the image and push it to Docker Hub for distribution.

Explore essential docker commands to manage images, containers, and connections. Learn to pull images, run and stop containers, view ports and live stats, and connect to containers.

Understand Kubernetes architecture, from master components (API server, Excel, scheduler, controller manager) to worker nodes (kubelet, kube-proxy), and how they enable service discovery, load balancing, storage orchestration, and automated rollouts.

Explore core Kubernetes fundamentals—pods, replica sets, deployments, and services—and compare imperative kubectl workflows with declarative YAML manifests for hands-on learning.

Understand the Kubernetes pod as the smallest deployable unit, usually one container per pod, scaled by adding pods; multi-container pods are rare, often for sidecars.

Create and delete a pod in Azure AKS using kubectl, configure credentials, run an image, and inspect with get ports and describe.

expose your application running in an Azure Kubernetes Service cluster through a load balancer service, mapped to Azure standard load balancer with a public IP.

Expose a port as a load balancer service in Azure Kubernetes Service, verify the Azure standard load balancer, obtain a public IP, and access your app in the browser.

Interact with pods using kubectl to list pods, view and stream logs, and connect via exec. Clean up by deleting pods and services, and verify resources in the default namespace.

Explore how Kubernetes replica sets maintain a stable pod replica count to ensure high availability, enable seamless scaling, and support load balancing with services through labels and selectors.

Create a replica set with three replicas from replicaset-demo.yml, then verify pods and owner references to confirm they belong to my-helloworld-rs and run kube-helloworld:1.0.0.

Expose a replica set as a load-balanced service with kubectl expose, mapping port 80 to 8080, then test availability and scalability by auto-recreating pods and scaling from 3 to 6.

Explore how deployments supersede replica sets to roll out new versions, enable rollback, scale, pause and resume, and support canary deployments with service exposure.

Create a deployment with kubectl, then scale to multiple replicas, expose it as a load-balanced service, and access the nginx-based app in a browser while reviewing replica sets and ports.

Learn to update Kubernetes deployments with set image or edit deployment, upgrade container images from 1.0.0 to 2.0.0 and 3.0.0, and verify rolling updates via status and history.

Learn how to roll back Kubernetes deployments using kubectl rollout history and kubectl rollout undo, reverting to the previous or a specific revision through rolling updates.

Pause deployments to apply multiple changes, then resume to rollout update from V3 to V4 while adding CPU and memory limits, verifying rollout history and replica sets.

Explore the core Kubernetes services—ClusterIP, NodePort, LoadBalancer, Ingress, and ExternalName—and learn how each enables internal cluster communication, external access, and cross-application routing.

Demonstrate Kubernetes services using kubectl: deploy a backend, expose a cluster IP service and a load balancer for an nginx frontend, and observe load balancing across replicas in AKS.

learn to create pods, ReplicaSets, deployments, and services declaratively using yaml and kubectl, transitioning from imperative commands to declarative Kubernetes resource management.

Explore YAML basics for Kubernetes manifests, focusing on key value pairs, dictionaries, lists, and document separators. Write readable configurations with proper indentation in VS Code, using .yaml or .yml extensions.

configure a pod using yaml by defining api version, kind, metadata, and spec, including a single container with image and port, then deploy with kubectl.

Learn to create a load balancer service in Kubernetes with yaml, defining apiVersion v1, kind: service, and port and selector settings to route traffic to pods labeled app.

Create a replica set YAML, apply it to the Kubernetes cluster, and deploy a load balancer service to access the three-replica app via the browser.

Create a YAML deployment from replica set, set image to 3.0 and labels to my app 3, then deploy and test with kubectl apply for deployment and load balancer service.

Create a backend k8s deployment and a cluster ip service using YAML, then set up a frontend load balancer service, test via kubectl in a VS Code workflow.

Create and test a front-end Nginx deployment and a load balancer service in Kubernetes using YAML definitions and kubectl, then verify external access to the hello endpoint.

Explore Azure disks for AKS storage, covering storage classes, persistent volumes and claims, deployments, config maps, and ClusterIP and load balancer services for the Maya scale app.

Create a custom storage class and persistent volume claim manifests for AKS using Azure Disk, configuring retain policy and wait-for-first-consumer binding, then deploy and test the setup.

Create a persistent volume claim manifest and deploy the Azure manager disc PVC with the manager premium retail SC. Verify storage class and PVC states.

Create a config map manifest to store non-confidential data as key-value pairs and mount it as a volume to initialize a default web app DB in MySQL.

Create a MySQL deployment manifest with environment variables and volume mounts, using a replica with recreate strategy, mounting an Azure manager disk PVC and a user management script via docker-entrypoint-initdb.d.

Create a MySQL cluster IP service manifest with clusterIP: none, deploy all manifests, and test the MySQL pod, PVC, and PV; observe Azure disk retention.

Learn to switch from a custom storage class to AKS system provisioned storage class (managed premium) for MySQL, creating PVCs and PVs with automatic deletion.

Deploy a user management web app on Kubernetes with a MySQL database, using a deployment manifest and init containers, configure environment variables, and expose via a load balancer service.

Create a user management web app load balancer service, deploy the app and MySQL, verify startup with init containers, access the app, and clean up Azure disks and resources.

Explore why azure mysql database is preferred for aks workloads over azure disks, and how to connect with the ExternalName service, featuring high availability, backups, and point-in-time restore.

Create an Azure database for MySQL flexible server configured for development with 1 vCore, 2 GiB RAM, 20 GiB storage, and public access enabled, then test connectivity.

Create the webappdb schema on the Azure MySQL flexible server and disable require_secure_transport, then connect using Azure Cloud Shell or a kubectl-driven MySQL 8.0 client.

Review the Kubernetes manifest for an external name service, deploy the user management web app to AKS, connect to Azure MySQL flexible servers, test user creation, and clean up resources.

Learn to create and reference Kubernetes secrets to securely store a MySQL password, encode it in base64, and inject it into deployments via secret key references.

this lecture covers azure file shares for aks storage, highlighting secure, fully managed shares with smb 3.0 and https, and how storage class, pv/pvc, and mounting support nginx deployments.

Review the kube manifest v1 for azure file storage class, persistent volume claim, nginx deployment, and load balancer service to provision and mount a persistent file share.

Deploy and verify azurefile-backed storage in AKS, upload static files to a mounted azure file share, test access, and clean up using kube manifests.

Explore ingress in Azure Kubernetes service, including ingress controller and resource, enabling a single ip with context- and host-based routing, tls termination, and external dns with Let's Encrypt.

Master ingress basics by installing the nginx ingress controller on Azure AKS with a static public IP, deploying a sample nginx app behind an ingress manifest.

Create a static standard public IP in the AKS resource group for ingress using az network public ip create, then locate and note the IP address for deployment.

Install and configure the nginx ingress controller on an Azure AKS cluster with Helm, create the ingress-basic namespace, override key values, and verify resources via kubectl and the load balancer.

Review and deploy k8s manifests, create an nginx ingress v1 manifest with host-based and path-based routing, and configure a cluster IP service as the backend for AppOne.

Deploy the app with ingress resources, verify pods and ingress, check the controller logs, access the app via the ingress address, and clean up the resources.