Kubernetes Autoscaling Complete Guide (Part 1): Horizontal Pod Autoscaler

 1apiVersion: autoscaling/v2
 2kind: HorizontalPodAutoscaler
 3metadata:
 4  name: webapp-hpa
 5  namespace: production
 6spec:
 7  scaleTargetRef:
 8    apiVersion: apps/v1
 9    kind: Deployment
10    name: webapp
11
12  minReplicas: 2
13  maxReplicas: 10
14
15  metrics:
16  - type: Resource
17    resource:
18      name: cpu
19      target:
20        type: Utilization
21        averageUtilization: 70  # Target 70% CPU utilization

 1apiVersion: apps/v1
 2kind: Deployment
 3metadata:
 4  name: webapp
 5spec:
 6  replicas: 2
 7  template:
 8    spec:
 9      containers:
10      - name: webapp
11        image: myapp:v1.0
12        resources:
13          requests:
14            cpu: 250m      # Must define for HPA to work
15            memory: 256Mi
16          limits:
17            cpu: 500m
18            memory: 512Mi

 1apiVersion: autoscaling/v2
 2kind: HorizontalPodAutoscaler
 3metadata:
 4  name: advanced-webapp-hpa
 5  namespace: production
 6spec:
 7  scaleTargetRef:
 8    apiVersion: apps/v1
 9    kind: Deployment
10    name: webapp
11
12  minReplicas: 3
13  maxReplicas: 50
14
15  # Multiple metrics evaluation
16  metrics:
17  - type: Resource
18    resource:
19      name: cpu
20      target:
21        type: Utilization
22        averageUtilization: 70
23
24  - type: Resource
25    resource:
26      name: memory
27      target:
28        type: Utilization
29        averageUtilization: 80
30
31  # Fine-grained scaling control
32  behavior:
33    scaleDown:
34      stabilizationWindowSeconds: 300  # Wait 5 min before scale-down
35      policies:
36      - type: Percent
37        value: 50           # Max 50% scale-down per iteration
38        periodSeconds: 60
39      - type: Pods
40        value: 2            # Max 2 pods per minute
41        periodSeconds: 60
42      selectPolicy: Min     # Choose most conservative policy
43
44    scaleUp:
45      stabilizationWindowSeconds: 0     # Immediate scale-up
46      policies:
47      - type: Percent
48        value: 100          # Max 100% scale-up per iteration
49        periodSeconds: 15
50      - type: Pods
51        value: 4            # Max 4 pods per 15 seconds
52        periodSeconds: 15
53      selectPolicy: Max     # Choose most aggressive policy

 1# Install Metrics Server (if not already installed)
 2kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
 3
 4# Create HPA
 5kubectl apply -f webapp-hpa.yaml
 6
 7# Monitor HPA status
 8kubectl get hpa webapp-hpa --watch
 9
10# View detailed HPA information
11kubectl describe hpa webapp-hpa
12
13# Check current metrics
14kubectl top pods -l app=webapp
15
16# Generate load for testing
17kubectl run -it --rm load-generator --image=busybox:1.28 --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://webapp-service; done"
18
19# Monitor scaling events
20kubectl get events --sort-by='.lastTimestamp' | grep HorizontalPodAutoscaler

 1// Example: Expose custom metrics in Go application
 2package main
 3
 4import (
 5    "github.com/prometheus/client_golang/prometheus"
 6    "github.com/prometheus/client_golang/prometheus/promhttp"
 7    "net/http"
 8)
 9
10var (
11    httpRequestsTotal = prometheus.NewCounterVec(
12        prometheus.CounterOpts{
13            Name: "http_requests_total",
14            Help: "Total number of HTTP requests",
15        },
16        []string{"method", "endpoint", "status"},
17    )
18
19    activeRequests = prometheus.NewGauge(
20        prometheus.GaugeOpts{
21            Name: "http_requests_active",
22            Help: "Number of active HTTP requests",
23        },
24    )
25)
26
27func init() {
28    prometheus.MustRegister(httpRequestsTotal)
29    prometheus.MustRegister(activeRequests)
30}
31
32func main() {
33    http.Handle("/metrics", promhttp.Handler())
34    http.ListenAndServe(":9090", nil)
35}

 1apiVersion: v1
 2kind: ConfigMap
 3metadata:
 4  name: prometheus-config
 5  namespace: monitoring
 6data:
 7  prometheus.yml: |
 8    global:
 9      scrape_interval: 15s
10      evaluation_interval: 15s
11
12    scrape_configs:
13    - job_name: 'webapp'
14      kubernetes_sd_configs:
15      - role: pod
16        namespaces:
17          names:
18          - production
19      relabel_configs:
20      - source_labels: [__meta_kubernetes_pod_label_app]
21        action: keep
22        regex: webapp
23      - source_labels: [__meta_kubernetes_pod_name]
24        target_label: pod
25      - source_labels: [__address__]
26        target_label: __address__
27        regex: ([^:]+)(?::\d+)?
28        replacement: $1:9090    

 1apiVersion: v1
 2kind: ConfigMap
 3metadata:
 4  name: adapter-config
 5  namespace: monitoring
 6data:
 7  config.yaml: |
 8    rules:
 9    - seriesQuery: 'http_requests_total{namespace="production",pod!=""}'
10      resources:
11        overrides:
12          namespace: {resource: "namespace"}
13          pod: {resource: "pod"}
14      name:
15        matches: "^(.*)_total$"
16        as: "${1}_per_second"
17      metricsQuery: 'sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m])) by (<<.GroupBy>>)'
18
19    - seriesQuery: 'http_requests_active{namespace="production"}'
20      resources:
21        overrides:
22          namespace: {resource: "namespace"}
23          pod: {resource: "pod"}
24      name:
25        as: "active_requests"
26      metricsQuery: 'sum(<<.Series>>{<<.LabelMatchers>>}) by (<<.GroupBy>>)'    
27
28---
29apiVersion: apps/v1
30kind: Deployment
31metadata:
32  name: prometheus-adapter
33  namespace: monitoring
34spec:
35  replicas: 1
36  selector:
37    matchLabels:
38      app: prometheus-adapter
39  template:
40    metadata:
41      labels:
42        app: prometheus-adapter
43    spec:
44      serviceAccountName: prometheus-adapter
45      containers:
46      - name: prometheus-adapter
47        image: directxman12/k8s-prometheus-adapter:v0.11.0
48        args:
49        - --cert-dir=/var/run/serving-cert
50        - --config=/etc/adapter/config.yaml
51        - --prometheus-url=http://prometheus-service:9090
52        - --metrics-relist-interval=30s
53        volumeMounts:
54        - name: config
55          mountPath: /etc/adapter
56      volumes:
57      - name: config
58        configMap:
59          name: adapter-config

 1apiVersion: autoscaling/v2
 2kind: HorizontalPodAutoscaler
 3metadata:
 4  name: webapp-custom-hpa
 5  namespace: production
 6spec:
 7  scaleTargetRef:
 8    apiVersion: apps/v1
 9    kind: Deployment
10    name: webapp
11
12  minReplicas: 2
13  maxReplicas: 20
14
15  metrics:
16  # Request rate-based scaling
17  - type: Pods
18    pods:
19      metric:
20        name: http_requests_per_second
21      target:
22        type: AverageValue
23        averageValue: "1000"  # Target 1000 req/s per pod
24
25  # Active connection-based scaling
26  - type: Pods
27    pods:
28      metric:
29        name: active_requests
30      target:
31        type: AverageValue
32        averageValue: "50"    # Target 50 concurrent requests per pod
33
34  behavior:
35    scaleUp:
36      stabilizationWindowSeconds: 0
37      policies:
38      - type: Percent
39        value: 100
40        periodSeconds: 15
41      - type: Pods
42        value: 3
43        periodSeconds: 15
44
45    scaleDown:
46      stabilizationWindowSeconds: 180
47      policies:
48      - type: Percent
49        value: 25
50        periodSeconds: 60

 1apiVersion: autoscaling/v2
 2kind: HorizontalPodAutoscaler
 3metadata:
 4  name: advanced-custom-hpa
 5  namespace: production
 6spec:
 7  scaleTargetRef:
 8    apiVersion: apps/v1
 9    kind: Deployment
10    name: webapp
11
12  minReplicas: 3
13  maxReplicas: 100
14
15  metrics:
16  # Infrastructure metrics
17  - type: Resource
18    resource:
19      name: cpu
20      target:
21        type: Utilization
22        averageUtilization: 70
23
24  # Application performance metrics
25  - type: Pods
26    pods:
27      metric:
28        name: http_request_duration_p99_seconds
29      target:
30        type: AverageValue
31        averageValue: "500m"  # 500ms P99 latency threshold
32
33  # Business metrics
34  - type: Pods
35    pods:
36      metric:
37        name: order_processing_queue_depth
38      target:
39        type: AverageValue
40        averageValue: "10"    # 10 orders per pod in queue
41
42  # Custom application health metric
43  - type: Pods
44    pods:
45      metric:
46        name: error_rate_per_second
47      target:
48        type: AverageValue
49        averageValue: "5"     # Max 5 errors/second per pod

 1# Rate-based scaling pattern
 2metrics:
 3- type: Pods
 4  pods:
 5    metric:
 6      name: requests_per_second
 7    target:
 8      type: AverageValue
 9      averageValue: "100"
10
11# Latency-based scaling pattern
12- type: Pods
13  pods:
14    metric:
15      name: request_duration_p99
16    target:
17      type: AverageValue
18      averageValue: "200m"  # 200ms
19
20# Queue-based scaling pattern
21- type: Pods
22  pods:
23    metric:
24      name: queue_messages_ready
25    target:
26      type: AverageValue
27      averageValue: "30"

 1# Verify Prometheus Adapter is running
 2kubectl get pods -n monitoring -l app=prometheus-adapter
 3
 4# Check available custom metrics
 5kubectl get --raw /apis/custom.metrics.k8s.io/v1beta1 | jq .
 6
 7# Query specific metric
 8kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1/namespaces/production/pods/*/http_requests_per_second" | jq .
 9
10# Monitor HPA with custom metrics
11kubectl describe hpa webapp-custom-hpa -n production
12
13# View HPA metrics in real-time
14kubectl get hpa webapp-custom-hpa -n production --watch

 1apiVersion: apps/v1
 2kind: Deployment
 3metadata:
 4  name: aws-cloudwatch-adapter
 5  namespace: kube-system
 6spec:
 7  replicas: 1
 8  selector:
 9    matchLabels:
10      app: aws-cloudwatch-adapter
11  template:
12    metadata:
13      labels:
14        app: aws-cloudwatch-adapter
15    spec:
16      serviceAccountName: aws-cloudwatch-adapter
17      containers:
18      - name: adapter
19        image: chankh/k8s-cloudwatch-adapter:v0.10.0
20        env:
21        - name: AWS_REGION
22          value: us-west-2
23        - name: AWS_ACCESS_KEY_ID
24          valueFrom:
25            secretKeyRef:
26              name: aws-credentials
27              key: access-key-id
28        - name: AWS_SECRET_ACCESS_KEY
29          valueFrom:
30            secretKeyRef:
31              name: aws-credentials
32              key: secret-access-key

 1apiVersion: v1
 2kind: ConfigMap
 3metadata:
 4  name: cloudwatch-adapter-config
 5  namespace: kube-system
 6data:
 7  config.yaml: |
 8    externalRules:
 9    - resource:
10        resource: "deployment"
11      queries:
12      - name: sqs_queue_messages_visible
13        resource:
14          resource: "deployment"
15        queries:
16        - id: sqs_messages
17          metricStat:
18            metric:
19              namespace: AWS/SQS
20              metricName: ApproximateNumberOfMessagesVisible
21              dimensions:
22              - name: QueueName
23                value: order-processing-queue
24            period: 300
25            stat: Average
26          returnData: true    

 1apiVersion: autoscaling/v2
 2kind: HorizontalPodAutoscaler
 3metadata:
 4  name: order-processor-hpa
 5  namespace: production
 6spec:
 7  scaleTargetRef:
 8    apiVersion: apps/v1
 9    kind: Deployment
10    name: order-processor
11
12  minReplicas: 1
13  maxReplicas: 50
14
15  metrics:
16  - type: External
17    external:
18      metric:
19        name: sqs_queue_messages_visible
20        selector:
21          matchLabels:
22            queue: order-processing-queue
23      target:
24        type: AverageValue
25        averageValue: "30"  # 30 messages per pod
26
27  behavior:
28    scaleUp:
29      stabilizationWindowSeconds: 0
30      policies:
31      - type: Percent
32        value: 100
33        periodSeconds: 30
34
35    scaleDown:
36      stabilizationWindowSeconds: 300
37      policies:
38      - type: Pods
39        value: 1
40        periodSeconds: 60

 1apiVersion: autoscaling/v2
 2kind: HorizontalPodAutoscaler
 3metadata:
 4  name: pubsub-consumer-hpa
 5  namespace: production
 6spec:
 7  scaleTargetRef:
 8    apiVersion: apps/v1
 9    kind: Deployment
10    name: pubsub-consumer
11
12  minReplicas: 2
13  maxReplicas: 100
14
15  metrics:
16  - type: External
17    external:
18      metric:
19        name: pubsub.googleapis.com|subscription|num_undelivered_messages
20        selector:
21          matchLabels:
22            resource.type: pubsub_subscription
23            resource.labels.subscription_id: event-processing-sub
24      target:
25        type: AverageValue
26        averageValue: "50"

1# Install KEDA using Helm
2helm repo add kedacore https://kedacore.github.io/charts
3helm repo update
4helm install keda kedacore/keda --namespace keda --create-namespace

 1apiVersion: apps/v1
 2kind: Deployment
 3metadata:
 4  name: kafka-consumer
 5  namespace: production
 6spec:
 7  replicas: 0  # KEDA will manage replicas
 8  selector:
 9    matchLabels:
10      app: kafka-consumer
11  template:
12    metadata:
13      labels:
14        app: kafka-consumer
15    spec:
16      containers:
17      - name: consumer
18        image: myapp/kafka-consumer:v1.0
19        env:
20        - name: KAFKA_BROKERS
21          value: "kafka-broker:9092"
22        - name: KAFKA_TOPIC
23          value: "order-events"
24        - name: KAFKA_CONSUMER_GROUP
25          value: "order-processor"
26        resources:
27          requests:
28            cpu: 100m
29            memory: 128Mi
30          limits:
31            cpu: 500m
32            memory: 512Mi
33
34---
35apiVersion: keda.sh/v1alpha1
36kind: ScaledObject
37metadata:
38  name: kafka-consumer-scaler
39  namespace: production
40spec:
41  scaleTargetRef:
42    name: kafka-consumer
43
44  # Scaling parameters
45  minReplicaCount: 0           # Scale to zero when idle
46  maxReplicaCount: 50          # Maximum scale-out
47  pollingInterval: 30          # Check every 30 seconds
48  cooldownPeriod: 300          # Wait 5 min before scale-down
49
50  triggers:
51  - type: kafka
52    metadata:
53      bootstrapServers: kafka-broker:9092
54      consumerGroup: order-processor
55      topic: order-events
56      lagThreshold: "50"         # Scale when lag > 50 messages per pod
57      offsetResetPolicy: latest

 1apiVersion: keda.sh/v1alpha1
 2kind: ScaledObject
 3metadata:
 4  name: advanced-event-processor
 5  namespace: production
 6spec:
 7  scaleTargetRef:
 8    name: event-processor
 9
10  minReplicaCount: 1
11  maxReplicaCount: 100
12
13  # Scale based on ANY trigger reaching threshold
14  triggers:
15  # Kafka lag-based scaling
16  - type: kafka
17    metadata:
18      bootstrapServers: kafka:9092
19      consumerGroup: processor-group
20      topic: events
21      lagThreshold: "100"
22
23  # RabbitMQ queue depth
24  - type: rabbitmq
25    metadata:
26      host: amqp://rabbitmq:5672
27      queueName: task-queue
28      queueLength: "30"
29
30  # AWS SQS integration
31  - type: aws-sqs-queue
32    metadata:
33      queueURL: https://sqs.us-west-2.amazonaws.com/123456/my-queue
34      queueLength: "20"
35      awsRegion: us-west-2
36    authenticationRef:
37      name: aws-credentials
38
39  # Prometheus metric-based
40  - type: prometheus
41    metadata:
42      serverAddress: http://prometheus:9090
43      metricName: pending_jobs
44      threshold: "50"
45      query: sum(job_queue_length{queue="processing"})
46
47  # Cron-based scaling (predictive)
48  - type: cron
49    metadata:
50      timezone: America/New_York
51      start: 0 8 * * *    # Scale up at 8 AM
52      end: 0 18 * * *     # Scale down at 6 PM
53      desiredReplicas: "20"
54
55  advanced:
56    horizontalPodAutoscalerConfig:
57      behavior:
58        scaleDown:
59          stabilizationWindowSeconds: 300
60          policies:
61          - type: Percent
62            value: 50
63            periodSeconds: 60
64        scaleUp:
65          stabilizationWindowSeconds: 0
66          policies:
67          - type: Percent
68            value: 100
69            periodSeconds: 15

 1apiVersion: keda.sh/v1alpha1
 2kind: ScaledObject
 3metadata:
 4  name: image-processor-scaler
 5  namespace: production
 6spec:
 7  scaleTargetRef:
 8    name: image-processor
 9
10  minReplicaCount: 0
11  maxReplicaCount: 200
12  pollingInterval: 10
13  cooldownPeriod: 120
14
15  triggers:
16  # Primary: S3 event notifications via SQS
17  - type: aws-sqs-queue
18    metadata:
19      queueURL: https://sqs.us-east-1.amazonaws.com/xxx/image-upload-queue
20      queueLength: "10"
21      awsRegion: us-east-1
22    authenticationRef:
23      name: aws-sqs-auth
24
25  # Secondary: Redis pending job count
26  - type: redis
27    metadata:
28      address: redis:6379
29      listName: image-processing-queue
30      listLength: "20"
31    authenticationRef:
32      name: redis-auth
33
34  # Fallback: Prometheus custom metric
35  - type: prometheus
36    metadata:
37      serverAddress: http://prometheus:9090
38      threshold: "50"
39      query: |
40        sum(rate(image_processing_requests_total[2m]))
41        -
42        sum(rate(image_processing_completed_total[2m]))        
43
44---
45apiVersion: v1
46kind: Secret
47metadata:
48  name: aws-sqs-auth
49  namespace: production
50type: Opaque
51data:
52  AWS_ACCESS_KEY_ID: <base64-encoded>
53  AWS_SECRET_ACCESS_KEY: <base64-encoded>
54
55---
56apiVersion: keda.sh/v1alpha1
57kind: TriggerAuthentication
58metadata:
59  name: aws-sqs-auth
60  namespace: production
61spec:
62  secretTargetRef:
63  - parameter: awsAccessKeyID
64    name: aws-sqs-auth
65    key: AWS_ACCESS_KEY_ID
66  - parameter: awsSecretAccessKey
67    name: aws-sqs-auth
68    key: AWS_SECRET_ACCESS_KEY

 1# Install KEDA
 2kubectl apply -f https://github.com/kedacore/keda/releases/download/v2.12.0/keda-2.12.0.yaml
 3
 4# Create ScaledObject
 5kubectl apply -f kafka-scaler.yaml
 6
 7# Check KEDA operator status
 8kubectl get pods -n keda
 9
10# View ScaledObject status
11kubectl get scaledobject -n production
12
13# Describe scaling behavior
14kubectl describe scaledobject kafka-consumer-scaler -n production
15
16# View underlying HPA created by KEDA
17kubectl get hpa -n production
18
19# Monitor scaling events
20kubectl get events -n production --field-selector involvedObject.name=kafka-consumer
21
22# Check KEDA metrics
23kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1/namespaces/production/kafka-consumer-scaler" | jq .

 1apiVersion: autoscaling.k8s.io/v1
 2kind: VerticalPodAutoscaler
 3metadata:
 4  name: webapp-vpa
 5spec:
 6  targetRef:
 7    apiVersion: apps/v1
 8    kind: Deployment
 9    name: webapp
10
11  updatePolicy:
12    updateMode: "Auto"  # Auto, Recreate, Initial, Off
13
14  resourcePolicy:
15    containerPolicies:
16    - containerName: webapp
17      minAllowed:
18        cpu: 100m
19        memory: 128Mi
20      maxAllowed:
21        cpu: 2
22        memory: 2Gi

 1behavior:
 2  scaleUp:
 3    # Aggressive scale-up for availability
 4    stabilizationWindowSeconds: 0
 5    policies:
 6    - type: Percent
 7      value: 100      # Double capacity quickly
 8      periodSeconds: 15
 9    selectPolicy: Max
10
11  scaleDown:
12    # Conservative scale-down for stability
13    stabilizationWindowSeconds: 300  # 5-minute observation
14    policies:
15    - type: Percent
16      value: 25       # Reduce gradually
17      periodSeconds: 60
18    selectPolicy: Min

1resources:
2  requests:
3    cpu: 250m       # Actual average usage
4    memory: 512Mi   # Working set size
5  limits:
6    cpu: 1000m      # 4x burst capacity
7    memory: 1Gi     # 2x headroom for spikes

 1# Step 1: Measure actual usage
 2kubectl top pods -l app=webapp --containers
 3
 4# Step 2: Calculate P90 values
 5kubectl get --raw "/apis/metrics.k8s.io/v1beta1/namespaces/production/pods" | \
 6  jq '.items[] | {name: .metadata.name, cpu: .containers[].usage.cpu, memory: .containers[].usage.memory}'
 7
 8# Step 3: Set requests to P50, limits to P90
 9# requests = average usage
10# limits = peak usage + 20% buffer

 1# Prometheus AlertManager rules
 2groups:
 3- name: autoscaling
 4  interval: 30s
 5  rules:
 6  # HPA not scaling when needed
 7  - alert: HPAMaxedOut
 8    expr: |
 9      kube_horizontalpodautoscaler_status_current_replicas
10      >= kube_horizontalpodautoscaler_spec_max_replicas      
11    for: 5m
12    labels:
13      severity: warning
14    annotations:
15      summary: "HPA {{ $labels.horizontalpodautoscaler }} at maximum capacity"
16
17  # HPA unable to fetch metrics
18  - alert: HPAMetricsMissing
19    expr: |
20      kube_horizontalpodautoscaler_status_condition{condition="ScalingActive",status="false"}
21      == 1      
22    for: 10m
23    labels:
24      severity: critical
25    annotations:
26      summary: "HPA {{ $labels.horizontalpodautoscaler }} cannot fetch metrics"
27
28  # Rapid scaling activity (possible thrashing)
29  - alert: HPAScalingThrashing
30    expr: |
31      rate(kube_horizontalpodautoscaler_status_current_replicas[15m]) > 0.5      
32    for: 30m
33    labels:
34      severity: warning
35    annotations:
36      summary: "HPA {{ $labels.horizontalpodautoscaler }} scaling too frequently"

 1# Install load testing tool
 2kubectl apply -f https://raw.githubusercontent.com/kubernetes/kubernetes/master/test/images/resource-consumer/controller.yaml
 3
 4# Generate sustained load
 5kubectl run -it --rm load-generator \
 6  --image=busybox:1.28 \
 7  --restart=Never \
 8  -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://webapp-service; done"
 9
10# Observe scaling behavior
11watch kubectl get hpa,pods -n production
12
13# Verify scaling events
14kubectl get events --sort-by='.lastTimestamp' | grep HorizontalPodAutoscaler
15
16# Check metrics during scaling
17kubectl top pods -l app=webapp --watch

 1# Simulate traffic spike
 2apiVersion: batch/v1
 3kind: Job
 4metadata:
 5  name: load-spike-test
 6spec:
 7  template:
 8    spec:
 9      containers:
10      - name: load-generator
11        image: williamyeh/hey:latest
12        args:
13        - -z
14        - 5m                # Duration
15        - -q
16        - "100"             # 100 req/s
17        - -c
18        - "50"              # 50 concurrent connections
19        - http://webapp-service
20      restartPolicy: Never

 1# Baseline tier: Always-on capacity
 2apiVersion: apps/v1
 3kind: Deployment
 4metadata:
 5  name: webapp-baseline
 6spec:
 7  replicas: 3  # Fixed baseline capacity
 8
 9---
10# Burst tier: Autoscaled capacity
11apiVersion: apps/v1
12kind: Deployment
13metadata:
14  name: webapp-burst
15spec:
16  replicas: 0  # KEDA managed
17
18---
19apiVersion: keda.sh/v1alpha1
20kind: ScaledObject
21metadata:
22  name: webapp-burst-scaler
23spec:
24  scaleTargetRef:
25    name: webapp-burst
26  minReplicaCount: 0
27  maxReplicaCount: 50
28  triggers:
29  - type: prometheus
30    metadata:
31      serverAddress: http://prometheus:9090
32      threshold: "1000"
33      query: sum(rate(http_requests_total[2m]))

1$ kubectl get hpa
2NAME       REFERENCE         TARGETS     MINPODS   MAXPODS   REPLICAS
3webapp     Deployment/webapp <unknown>   2         10        2

 1# Check HPA status
 2kubectl describe hpa webapp
 3
 4# Common issues:
 5# 1. Missing Metrics Server
 6kubectl get pods -n kube-system | grep metrics-server
 7
 8# 2. Missing resource requests
 9kubectl get deployment webapp -o yaml | grep -A 5 resources
10
11# 3. Metrics API not working
12kubectl get apiservice v1beta1.metrics.k8s.io -o yaml

1# Install Metrics Server
2kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
3
4# Add resource requests to deployment
5kubectl patch deployment webapp -p '{"spec":{"template":{"spec":{"containers":[{"name":"webapp","resources":{"requests":{"cpu":"100m","memory":"128Mi"}}}]}}}}'
6
7# Restart Metrics Server if needed
8kubectl rollout restart deployment metrics-server -n kube-system

1behavior:
2  scaleDown:
3    stabilizationWindowSeconds: 300  # Increase to 5 minutes
4    policies:
5    - type: Percent
6      value: 25              # Reduce from 50%
7      periodSeconds: 120     # Increase period

1# Check ScaledObject status
2kubectl describe scaledobject myapp-scaler
3
4# Check KEDA operator logs
5kubectl logs -n keda deployment/keda-operator
6
7# Verify trigger authentication
8kubectl get triggerauthentication -n production