apiVersion: apps/v1
kind: Deployment
metadata:
  name: php-apache
spec:
  replicas: 1
  selector:
    matchLabels:
      run: php-apache
  template:
    metadata:
      labels:
        run: php-apache
    spec:
      containers:
      - name: php-apache
        image: registry.k8s.io/hpa-example
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: 500m
          requests:
            cpu: 200m
---
apiVersion: v1
kind: Service
metadata:
  name: php-apache
  labels:
    run: php-apache
spec:
  ports:
  - port: 80
  selector:
    run: php-apache

2. Apply the manifest to your cluster:

kubectl apply -f app-deployment.yaml

3. Verify that the Pod is successfully created and running:

kubectl get pods

Step 3: Configure the Horizontal Pod Autoscaler (HPA)

The HPA will monitor the deployment and maintain between 1 and 10 replicas. It targets an average CPU utilization of 50% across all Pods.

1. Create a file named app-hpa.yaml:

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: php-apache
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  minReplicas: 1
  maxReplicas: 10
  targetCPUUtilizationPercentage: 50

2. Deploy the HPA configuration:

kubectl apply -f app-hpa.yaml

3. Check the HPA status:

kubectl get hpa

Note: Wait until the TARGETS column changes from <unknown>/50% to 0%/50%, indicating that the HPA has successfully bound to the metrics endpoint.

Step 4: Setup Port Forwarding & Load Test Script

Since Minikube runs inside an isolated Docker network, we must expose the service to our local Windows host machine using port forwarding.

1. Open a dedicated terminal window and run:

kubectl port-forward service/php-apache 8080:80

Keep this terminal running. The application is now accessible at http://localhost:8080. 2. Create the k6 load test configuration script named load-test.js:

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Ramp-up to 50 Virtual Users (VUs)
    { duration: '3m', target: 50 },  // Stay/Sustain 50 VUs to trigger HPA
    { duration: '1m', target: 0 },   // Ramp-down to 0 users
  ],
};

export default function () {
  http.get('http://localhost:8080');
  sleep(0.1); 
}

Step 5: Execution, Observation & Real Test Results

To witness the system scale dynamically, monitor the HPA in one terminal while executing the load test in another.

1. Terminal 1 (Monitoring): Start watching the HPA changes live:

kubectl get hpa php-apache --watch

2. Terminal 2 (Execution): Execute the load test via k6:

k6 run load-test.js

📊 Real Experiment Metrics & Timeline Analysis

Based on our live test logs, here is the chronological breakdown of the HPA behavior:

📈 Visual Autoscaling Behavior

The dynamic response of the system—showing the exact correlation between the massive CPU utilization spike and the immediate reactive scale-up of pod counts—is visualized in the graph chart saved inside this repository as grafik-autoscaling.png.

The graph perfectly demonstrates how cloud-native infrastructure ensures high availability during peak traffic while optimizing operational infrastructure costs during downtime.