As a DevOps enthusiast, I recently embarked on a journey to implement robust resource management policies in my Kubernetes cluster. This project was inspired by Abhishek Veeramalla's excellent tutorial on Kubernetes security, which opened my eyes to the power of Kyverno for policy enforcement.

The Beginning

When I first started working with Kubernetes, one of the biggest challenges was ensuring consistent resource allocation across all pods. We've all been there - some pods consuming too many resources while others starve. That's when I stumbled upon Abhishek's tutorial on using Kyverno for Kubernetes security, and it was exactly what I needed.

Why Kyverno?

Before diving into the implementation, let me share why Kyverno caught my attention:

• It's Kubernetes-native
• Uses familiar YAML syntax
• No need to learn a new policy language
• Real-time enforcement capabilities

The Implementation Journey

Setting Up the Foundation

I started with a fresh EKS cluster and immediately faced my first challenge - connecting to the cluster. The classic "connection refused" error that every Kubernetes developer knows too well! After proper AWS CLI configuration and updating my kubeconfig, I was ready to roll.

The Installation Marathon

First came ArgoCD:

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Then Kyverno:

helm repo add kyverno https://kyverno.github.io/kyverno/
helm repo update
helm install kyverno kyverno/kyverno -n kyverno --create-namespace

The First Hurdle: Case Sensitivity

My first real challenge came when implementing the resource validation policy. The error message was clear yet confusing:

The ClusterPolicy "require-requests-limits" is invalid: spec.validationFailureAction: Unsupported value: "Audit"

Who would have thought that "Audit" vs. "audit" would cause such a headache? This was my first lesson in Kyverno's attention to detail.

The Policy Evolution

I started with a basic policy in audit mode, but soon realized I needed stricter enforcement. The transition from audit to enforce mode was nerve-wracking - nobody wants to accidentally block legitimate deployments! Here's the final policy that worked:

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: require-requests-limits
spec:
  validationFailureAction: enforce
  rules:
  - name: validate-resources
    match:
      any:
      - resources:
          kinds:
          - Pod
    validate:
      message: "CPU and memory resource requests and limits are required."
      pattern:
        spec:
          containers:
          - resources:
              requests:
                memory: "?*"
                cpu: "?*"
              limits:
                memory: "?*"
                cpu: "?*"

Key Learnings

1. Start with Audit Mode: Always begin with audit mode to understand the impact of your policies.
2. Case Sensitivity Matters: Kyverno is very particular about syntax and case.
3. Test, Test, Test: Create test pods to verify policy enforcement.

Acknowledgments

A special thanks to Abhishek Veeramalla for his excellent tutorial that got me started on this journey.