Multi-tenant Cluster

One Cluster. Multi-tenant. GitOps practices.

A multi-tenant EKS cluster that runs many teams on shared infrastructure. Terraform provisions AWS; ArgoCD runs everything above the API server via GitOps.

  • AWS EKS
  • Terraform
  • ArgoCD
  • Karpenter
  • Istio ambient
  • AWS Load Balancer Controller
  • cert-manager
  • External Secrets
  • Kyverno
GitHub Repository

Business Challenge & Solution

For a small or mid-size enterprise, giving every product team its own Kubernetes cluster drives up cost, slows onboarding, and leaves governance inconsistent.

How can one cluster serve many teams while keeping workloads isolated, secure, and easy to operate?

This project answers the challenge with a multi-tenant cluster on AWS EKS.

Benefits

  • Lower cost. Pooled capacity replaces per-team over-provisioning.
  • One platform to run. One control plane, one upgrade path, one security baseline.
  • Consistent governance. The same guardrails apply to every tenant.
  • Fast onboarding. A new team goes live in minutes, driven by GitOps.

Architecture & Capabilities

Terraform provisions the AWS foundation. ArgoCD bootstraps everything above the API server via GitOps.

High-level architecture diagram
  1. Terraform provisions the AWS foundation (VPC, EKS, IAM, Route53).
  2. ArgoCD bootstraps platform capabilities on the cluster.
  3. Per-tenant AppProjects and ApplicationSets sync each team’s own manifest repo.

Four out-of-the-box capabilities

Capability Tooling What tenants get
Compute Karpenter + workload classes On-demand nodes by class (general / database / gpu)
Storage AWS EBS CSI + StorageClasses PVCs on gp3 (default) or gp3-iops (high-IOPS)
Network Istio ambient + Gateway API + ALBC + external-dns Public URL under <team>.arguswatcher.net, TLS, DNS, mTLS
Security ESO + Pod Identity + cert-manager + Kyverno Secret vending, AWS access, wildcard TLS, admission control

Shared responsibility model

Shared responsibility model between platform and tenants
A clear boundary: platform owns the guardrails; tenants own their workloads.

Tenant Onboarding

Onboarding a new team takes 3 pieces of info and 1 JSON file. GitOps handles the rest.

The onboarding recipe

  • Tenant provides. Three fields: name, sourceRepo, manifestPath.
  • Platform commits. A single tenants/<team>.json in the platform repo.
  • GitOps handles. Namespace, AppProject, ApplicationSet, subdomain, TLS, policy.
tenants/team-a.json
{
  "name": "team-a",
  "sourceRepo": "https://github.com/simonangel-fong/eks-multi-tenant-cluster",
  "manifestPath": "demo-app/team-a"
}
Time to live URL: ~3 min for stateless · ~2 min additional for stateful (PVC + database node).

Sample Demo: Team A, Stateless App

Team A

A simple nginx web app deployed with plain Kubernetes manifests.

Node class
general
Public URL
team-a.arguswatcher.net
Team A stateless web app running

Sample Demo: Team B, Stateful App

Team B

A full-stack to-do app packaged as a Helm chart with a persistent database.

Node classes
general · database
Public URL
team-b.arguswatcher.net
Team B stateful to-do app running

Summary

A multi-tenant cluster gives small and mid-size companies a clear responsibility boundary between the platform team and tenant teams.

For the platform team

  • Clear ownership Focus on platform capabilities and the underlying infrastructure. Nothing tenant-specific.
  • Lower operational overhead Run one cluster instead of one per team. One upgrade path, one security baseline.
  • Centralized compliance One policy set applies to every tenant, enforced automatically at admission.

For the tenant team

  • Clear ownership Focus on the application. Manifests live in the tenant’s own Git repo; GitOps keeps the cluster in sync.
  • Automatic infrastructure Compute, storage, network, and security come out of the box. No manual configuration.
  • Simple onboarding Three fields (name, sourceRepo, manifestPath). App is live in minutes.