Azure Kubernetes Service (AKS) for AI Agents

Access the course labs in a public GitHub repository, clone them into VS Code, and explore multi-container patterns, rack patterns, and rack pipelines in AKS with Azure OpenAI via step-by-step instructions.

Explore the evolution of software architectures from monolithic to microservices and serverless, and learn how docker containers, docker images, and containerization enable scalable CI/CD on Azure Kubernetes Service.

Learn how Kubernetes orchestrates containers with pods on nodes, and how Azure Kubernetes Service manages the control plane so you deploy containerized apps via yaml manifests.

Understand Kubernetes architecture through a restaurant analogy, pairing the control plane with management staff and the compute plane with kitchen pods, while etcd, kube API server, and scheduler coordinate workloads.

Master Kubernetes workload objects, including deployments, statefulsets, daemonsets, and jobs and cron jobs, and learn how YAML manifests drive stateless and stateful workloads through the control plane.

Acquire an understanding of AKS networking, including container-to-container and external-to-service flows, and learn how services expose pods with cluster IP, node port, and Azure load balancer.

Provision a new AKS cluster in the Azure portal, configure a dev/test node pool, connect an Azure Container Registry, and enable monitoring with Azure Monitor and Grafana.

Begin lab one of Azure AI with AKS by cloning repo and connecting to AKS cluster with az login and az aks get credentials; explore kube control deployments in kube-system.

Build a simple AI chat app on Kubernetes using Azure AI Foundry GPT engines and prompt flow, with a dockerized React front end deployed to AKS via deployment.yaml.

Deploy an Azure AI Foundry hub and project, configure a GPT-4 model, and integrate it with a React.js application, then test via the studio playground.

Build a containerized React.js chat app with Docker Desktop, configure Azure OpenAI GPT-4 endpoint and API key, then push the image to Azure Container Registry for AKS deployment.

Push the containerized Azure OpenAI chat app from Docker Hub to Azure Container Registry, deploy to Azure Kubernetes Service via deployment YAML and kubectl, then port-forward to localhost:8080.

Set resource limits in a YAML deployment to reserve CPU and memory for the Azure OpenAI chat app image from Azure Container Registry, deploying two pods in AKS.

Set pod anti-affinity rules in deployment.yaml to distribute pods across nodes, preventing co-location and improving high availability in azure kubernetes service deployments.

Deploy a stateful set in AKS to preserve pod identities with a headless service. Scale replicas and observe the DNS-named pods and their ordered lifecycle.

Expose an Azure OpenAI chat application on AKS by creating a front-end Azure load balancer, mapping external IP to a two-pod deployment through backend rules and health checks.

Master how to use config maps and secrets in Azure Kubernetes Service (AKS) to supply the endpoint, API key, and model name to a container at runtime.

Explore configuring a Python Flask app with config maps in AKS, deploy via Docker and Azure Container Registry, and expose a /chat endpoint to Azure OpenAI.

Demonstrates running an AI app in AKS with config maps and secrets, storing the Azure OpenAI endpoint and model name in a config map, and API key in a secret.

Learn the architecture of Azure AI agents on AKS through labs that containerize a Python Flask backend, connect to Azure OpenAI, and route frontend and backend traffic with cluster IP.

Explore Kubernetes multi-container patterns, including init containers and sidecar containers, with AKS use case using Azure OpenAI, content filtering, and logs to Azure Cosmos DB on a shared file system.

Deploy a simple frontend-backend chat app with a multi-container design and sidecar pattern on Azure Kubernetes Service, linking a React frontend to a Python backend using Azure OpenAI.

Explore multi-container design patterns in AKS by deploying front-end and back-end chat apps across two pods, exposing a cluster IP service for inter-pod communication and internal routing.

Explore advanced Kubernetes concepts like multi-container patterns, ingress routing, and helm charts to build a rag pipeline with front-end, back-end, and vector database in AKS.

Understand retrieval augmented generation (rag) and its three components, retrieval, augment, and generation, to build a chatbot that answers from your own data using vector embeddings and a vector database.

Introduce the open-source vector database used in this module. Learn to run it in Docker, map port 6333, and load sample data via the dashboard for a chatbot-ready vectors collection.

Implement a two-container sidecar design to preload text and 1536-d vector embeddings into quadrant DB for Maggie's Travel, using Azure OpenAI embeddings and localhost 6333 communication.

Explore how persistent volumes and persistent volume claims enable durable storage in Azure Kubernetes Service, using Azure file shares and dynamic provisioning to keep data safe across pod restarts.

Deploy a full rag app on Azure Kubernetes Service with PVC-backed storage, a React front end, and a Flask back end leveraging Quadrant DB and Azure OpenAI for summarization.

Learn how ingress and ingress controllers in AKS enable domain-based routing for multiple microservices, exposing https routes with TLS, load balancing, and request logs across APIs and dashboards.

Configure an Azure managed nginx ingress for a RAG app on AKS, exposing front end, back end, and quadrant DB via cluster IP services and path-based routing.

Understand how Helm charts template complex apps into deployable units, enabling environment-specific deployments in AKS via a single template stored in Azure Container Registry.

Learn to template and deploy a multi-container rag app on AKS with helm charts, using values.yaml, pvc, statefulset, and config maps for Azure OpenAI GPT-4 and Ada-002.

Push and pull helm charts to Azure Container Registry using OCI, then deploy the charts to an AKS cluster with Helm and Azure CLI.

Implement canary deployment to migrate from GPT 4.1 to GPT 4 in AKS, routing 25% of traffic to the new model and validating performance.

Explore rolling updates in Azure Kubernetes Service, upgrading a GPT-4.1 app to GPT-4 with maximum search and maximum unavailable, using deployment.yaml, and performing rollback.

Explore observability and maintenance in an AKS cluster using Copilot, Workbooks, and Log Analytics. Learn to fetch pod logs, inspect deployments, and run Kusto queries for real-time insights.

Explore Kubernetes event driven autoscaling (Keda) in AKS. See how scaled objects, triggers, and external metrics enable horizontal and vertical pod autoscaling with Azure services.

Configure a cron-based Keda scaled object on AKS to autoscale a GPT-4.1 Flask app from 1 to 5 pods during a 30th-45th minute window, using AKS, ACR, and CRD.

Learn vertical pod autoscaling on AKS with a GPT-4 app, as VPA adjusts CPU and memory allocations to pods based on workload, keeping at least one pod up and running.