Back to projects

Kubernetes Application Orchestration & Delivery

Deployed a containerised app with Kubernetes to gain hands-on experience with the core building blocks: Deployments, Services, Ingress, autoscaling, and Helm-based releases in a way that matches real AKS delivery patterns.

Impact

Deployed and scaled a containerised app using core Kubernetes resources.
Built a clear understanding of Kubernetes networking (Pod ↔ Service ↔ Ingress).
Delivered the app using Helm in a CI/CD-friendly way.

The goal was practical experience delivering and operating workloads on Kubernetes, including how traffic routing and scaling work end-to-end.

  • Kubernetes adds moving parts (networking, scaling, rollout management) compared to managed container platforms.
  • To run services reliably, you need to understand how Pods, Services, and Ingress fit together.
  • Raw YAML becomes hard to manage across environments without a packaging/release approach.
  • Deploy an app using Deployments and Services.
  • Expose the app through Ingress (not NodePort) to reflect typical production access patterns.
  • Use Helm to manage releases and keep deployments consistent.
  • Add Horizontal Pod Autoscaling (HPA) based on CPU usage.
  • Follow a CI/CD approach that maps well to AKS-style workflows.
  • Node.js application containerised with Docker.
  • Kubernetes Deployment for replicas and rolling updates.
  • ClusterIP Service for stable internal access and load balancing.
  • NGINX Ingress Controller for HTTP routing.
  • Helm chart to template and manage Kubernetes resources.
  • Horizontal Pod Autoscaler configured using metrics-server.
  • CI builds and tags container images.
  • Images published to a container registry.
  • CD deploys using Helm upgrade/install.
  • Image tags added at deploy time to trigger rolling updates.
  • Checked that deployments completed successfully and pods were healthy.
Helm instead of raw manifests
More to learn up front, but better reuse, cleaner releases, and easier environment differences.
Ingress instead of NodePort
Extra setup, but far closer to how traffic is handled in real clusters.
  • Kept secrets out of manifests/values (no hardcoded credentials).
  • Separated application workloads from the ingress layer to improve security.
  • Ready for managed identity patterns when moving to AKS.
  • Rolling updates reduce downtime during releases.
  • HPA enables scaling based on demand.
  • Service abstraction keeps networking stable even as pods change.
  • End-to-end Kubernetes deployment flow built locally using Docker Desktop.
  • More confidence operating containerised workloads and troubleshooting common issues.
  • Solid foundation for working with managed Kubernetes platforms like AKS.
  • Use Terraform to provision AKS and supporting infrastructure.
  • Add environment-specific Helm values for multi-stage promotion.
  • Add cluster-level protection (policy and security controls).