_ 📋 Kopieren Sie alle KEDA Befehle_ 📄 Generieren KEDA PDF Guide_HTML_TAG_105___

_

KEDA (Kubernetes Event-Driven Autoscaling) Cheatsheet

• Installation

Platform/Method	Command
Helm (Recommended)	INLINE_CODE_12
YAML Manifest	INLINE_CODE_13
Specific Version	INLINE_CODE_14
macOS (Prerequisites)	INLINE_CODE_15
Windows (Prerequisites)	INLINE_CODE_16
OpenShift OperatorHub	Navigate to: Operators → OperatorHub → Search "KEDA"
Upgrade Existing	INLINE_CODE_17
Uninstall	INLINE_CODE_18
_
### Verification Commands

Command	Description
INLINE_CODE_19	Check KEDA components are running
INLINE_CODE_20	Verify KEDA CRDs are installed
INLINE_CODE_21	Check KEDA operator deployment
INLINE_CODE_22	Verify metrics API service

oder Grundlegende Befehle

Scaled Projektleitung

Command	Description
INLINE_CODE_23	List all ScaledObjects in current namespace
INLINE_CODE_24	List ScaledObjects (short form)
INLINE_CODE_25	List ScaledObjects across all namespaces
INLINE_CODE_26	List ScaledObjects in specific namespace
INLINE_CODE_27	Show detailed information about a ScaledObject
INLINE_CODE_28	View ScaledObject YAML configuration
INLINE_CODE_29	Watch ScaledObject status changes in real-time
INLINE_CODE_30	Delete a ScaledObject
INLINE_CODE_31	Edit ScaledObject configuration
INLINE_CODE_32	Create/update ScaledObject from file
_
### Scaled Job Management

Command	Description
INLINE_CODE_33	List all ScaledJobs in current namespace
INLINE_CODE_34	List ScaledJobs (short form)
INLINE_CODE_35	List ScaledJobs across all namespaces
INLINE_CODE_36	Show detailed information about a ScaledJob
INLINE_CODE_37	View ScaledJob YAML configuration
INLINE_CODE_38	Delete a ScaledJob
INLINE_CODE_39	View Jobs created by ScaledJob
INLINE_CODE_40	View logs from ScaledJob-created Job

Authentication Management

Command	Description
INLINE_CODE_41	List TriggerAuthentications
INLINE_CODE_42	List TriggerAuthentications (short form)
INLINE_CODE_43	Show TriggerAuthentication details
INLINE_CODE_44	List ClusterTriggerAuthentications
INLINE_CODE_45	List ClusterTriggerAuthentications (short form)
INLINE_CODE_46	Delete a TriggerAuthentication
INLINE_CODE_47	Create secret for TriggerAuthentication

Monitoring und Status

Command	Description
INLINE_CODE_48	View HPAs created by KEDA
INLINE_CODE_49	Show HPA details for scaled resource
INLINE_CODE_50	View recent scaling events
INLINE_CODE_51	Follow KEDA operator logs
INLINE_CODE_52	Follow metrics server logs
INLINE_CODE_53	View current pod resource usage
INLINE_CODE_54	Check current replica count

/ Fortgeschrittene Nutzung

Advanced Scaled Aufgabenbereich

Command	Description
INLINE_CODE_55	Pause autoscaling at specific replica count
INLINE_CODE_56	Resume autoscaling (remove pause)
INLINE_CODE_57	Update minimum replica count
INLINE_CODE_58	Update maximum replica count
INLINE_CODE_59	View ScaledObject status conditions
INLINE_CODE_60	View external metric names
INLINE_CODE_61	View target resource kind
_
### KEDA Operator Management

Command	Description
INLINE_CODE_62	Scale KEDA operator for HA
INLINE_CODE_63	Restart KEDA operator
INLINE_CODE_64	Check operator rollout status
INLINE_CODE_65	View KEDA component details
INLINE_CODE_66	View available Helm configuration options
INLINE_CODE_67	View current Helm installation values
INLINE_CODE_68	Update KEDA configuration
_
### Metrics and Debugging

Command	Description
INLINE_CODE_69	Query external metrics API
INLINE_CODE_70	Query specific external metric
INLINE_CODE_71	Check metrics API service status
INLINE_CODE_72	View recent operator logs
INLINE_CODE_73	View recent metrics server logs
INLINE_CODE_74	View KEDA namespace events
INLINE_CODE_75	View all KEDA-managed HPAs
_
### Multi-Trigger und komplexe Szenarien

Command	Description
INLINE_CODE_76	List all trigger types for a ScaledObject
INLINE_CODE_77	Check health status of triggers
INLINE_CODE_78	View last active time
INLINE_CODE_79	View current replica count
INLINE_CODE_80	View desired replica count

Konfiguration

Grundskala Objektkonfiguration

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: my-scaledobject
  namespace: default
spec:
  scaleTargetRef:
    name: my-deployment              # Target deployment name
  minReplicaCount: 0                 # Minimum replicas (0 for scale-to-zero)
  maxReplicaCount: 10                # Maximum replicas
  pollingInterval: 30                # Seconds between metric checks
  cooldownPeriod: 300                # Seconds to wait after last trigger
  triggers:
  - type: prometheus                 # Scaler type
    metadata:
      serverAddress: http://prometheus:9090
      metricName: http_requests_total
      threshold: '100'
      query: sum(rate(http_requests_total[2m]))

Scaled Objekt mit mehreren Triggern

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: multi-trigger-scaler
spec:
  scaleTargetRef:
    name: api-deployment
  minReplicaCount: 1
  maxReplicaCount: 50
  triggers:
  - type: prometheus
    metadata:
      serverAddress: http://prometheus:9090
      threshold: '100'
      query: sum(rate(http_requests_total[2m]))
  - type: cpu
    metricType: Utilization
    metadata:
      value: "70"
  - type: memory
    metricType: Utilization
    metadata:
      value: "80"

Scaled Objekt mit erweitertem HPA-Behavior

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: advanced-scaling
spec:
  scaleTargetRef:
    name: worker-deployment
  minReplicaCount: 2
  maxReplicaCount: 100
  advanced:
    restoreToOriginalReplicaCount: true
    horizontalPodAutoscalerConfig:
      behavior:
        scaleDown:
          stabilizationWindowSeconds: 300
          policies:
          - type: Percent
            value: 50              # Scale down max 50% at a time
            periodSeconds: 60
        scaleUp:
          stabilizationWindowSeconds: 0
          policies:
          - type: Percent
            value: 100             # Scale up max 100% at a time
            periodSeconds: 15
          - type: Pods
            value: 5               # Or add max 5 pods at a time
            periodSeconds: 15
          selectPolicy: Max        # Use the policy that scales faster
  triggers:
  - type: kafka
    metadata:
      bootstrapServers: kafka:9092
      consumerGroup: my-group
      topic: events
      lagThreshold: '10'

Scaled Jobkonfiguration

apiVersion: keda.sh/v1alpha1
kind: ScaledJob
metadata:
  name: batch-processor
spec:
  jobTargetRef:
    parallelism: 1
    completions: 1
    backoffLimit: 3
    template:
      spec:
        containers:
        - name: processor
          image: myapp:latest
          command: ["./process"]
        restartPolicy: Never
  pollingInterval: 30
  maxReplicaCount: 10
  successfulJobsHistoryLimit: 5
  failedJobsHistoryLimit: 5
  scalingStrategy:
    strategy: "default"           # or "custom", "accurate"
  triggers:
  - type: rabbitmq
    metadata:
      queueName: jobs
      host: amqp://guest:guest@rabbitmq:5672
      queueLength: '5'

TriggerAuthentication with Secret

apiVersion: v1
kind: Secret
metadata:
  name: rabbitmq-secret
type: Opaque
stringData:
  connection-string: "amqp://user:password@rabbitmq:5672"
---
apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: rabbitmq-auth
spec:
  secretTargetRef:
  - parameter: host
    name: rabbitmq-secret
    key: connection-string

ClusterTriggerAuthentication mit Pod Identity

apiVersion: keda.sh/v1alpha1
kind: ClusterTriggerAuthentication
metadata:
  name: aws-credentials
spec:
  podIdentity:
    provider: aws-eks              # or aws-kiam, azure, gcp
    identityId: arn:aws:iam::123456789012:role/keda-role

Helm Installation Werte

# values.yaml for Helm installation
operator:
  replicaCount: 2                  # HA setup

metricsServer:
  replicaCount: 2                  # HA setup

serviceAccount:
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::123456789012:role/keda-role

resources:
  operator:
    limits:
      cpu: 1000m
      memory: 1000Mi
    requests:
      cpu: 100m
      memory: 100Mi
  metricServer:
    limits:
      cpu: 1000m
      memory: 1000Mi
    requests:
      cpu: 100m
      memory: 100Mi

prometheus:
  operator:
    enabled: true
    podMonitor:
      enabled: true
  metricServer:
    enabled: true
    podMonitor:
      enabled: true

Häufige Anwendungsfälle

Use Case 1: RabbitMQ Queue-Based Scaling

Skalieren Sie eine Worker-Bereitstellung basierend auf Rabbit MQ Wartetiefe:

# Create secret with RabbitMQ credentials
kubectl create secret generic rabbitmq-secret \
  --from-literal=host='amqp://user:password@rabbitmq.default.svc.cluster.local:5672'

# Create TriggerAuthentication
kubectl apply -f - <<EOF
apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: rabbitmq-auth
spec:
  secretTargetRef:
  - parameter: host
    name: rabbitmq-secret
    key: host
EOF

# Create ScaledObject
kubectl apply -f - <<EOF
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: rabbitmq-scaler
spec:
  scaleTargetRef:
    name: worker-deployment
  minReplicaCount: 0
  maxReplicaCount: 30
  triggers:
  - type: rabbitmq
    metadata:
      protocol: amqp
      queueName: tasks
      mode: QueueLength
      value: '5'
    authenticationRef:
      name: rabbitmq-auth
EOF

# Monitor scaling
kubectl get scaledobject rabbitmq-scaler -w
kubectl get hpa
kubectl get deployment worker-deployment

Use Case 2: Kafka Consumer Group Lag Scaling

Waage Kafka-Verbraucher auf Basis der Verbrauchergruppenverzögerung:

# Create ScaledObject for Kafka
kubectl apply -f - <<EOF
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: kafka-consumer-scaler
spec:
  scaleTargetRef:
    name: kafka-consumer
  minReplicaCount: 1
  maxReplicaCount: 50
  triggers:
  - type: kafka
    metadata:
      bootstrapServers: kafka.default.svc.cluster.local:9092
      consumerGroup: my-consumer-group
      topic: events
      lagThreshold: '10'
      offsetResetPolicy: latest
EOF

# Check scaling status
kubectl describe scaledobject kafka-consumer-scaler
kubectl get hpa keda-hpa-kafka-consumer-scaler

# View external metrics
kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1/namespaces/default/s0-kafka-my-consumer-group" | jq

Use Case 3: Prometheus Metrics-Based Scaling

Skala basierend auf benutzerdefinierten Prometheus Metriken:

# Create ScaledObject with Prometheus trigger
kubectl apply -f - <<EOF
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: prometheus-scaler
spec:
  scaleTargetRef:
    name: api-server
  minReplicaCount: 2
  maxReplicaCount: 20
  triggers:
  - type: prometheus
    metadata:
      serverAddress: http://prometheus.monitoring.svc.cluster.local:9090
      metricName: http_requests_per_second
      threshold: '100'
      query: |
        sum(rate(http_requests_total{job="api-server"}[2m]))
EOF

# Verify Prometheus connectivity
kubectl logs -n keda deployment/keda-operator | grep prometheus

# Test scaling
kubectl get scaledobject prometheus-scaler -o jsonpath='{.status}'

Use Case 4: Cron-Based Scheduled Scaling

Skalieren Sie Workloads basierend auf Zeitplänen:

# Create ScaledObject with cron trigger for business hours
kubectl apply -f - <<EOF
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: scheduled-scaler
spec:
  scaleTargetRef:
    name: business-app
  minReplicaCount: 1
  maxReplicaCount: 1
  triggers:
  - type: cron
    metadata:
      timezone: America/New_York
      start: 0 8 * * 1-5          # 8 AM Mon-Fri
      end: 0 18 * * 1-5            # 6 PM Mon-Fri
      desiredReplicas: "10"
  - type: cron
    metadata:
      timezone: America/New_York
      start: 0 18 * * 1-5          # 6 PM Mon-Fri
      end: 0 8 * * 1-5             # 8 AM Mon-Fri
      desiredReplicas: "2"
EOF

# Monitor scheduled scaling
kubectl get scaledobject scheduled-scaler -w
kubectl get events --field-selector involvedObject.name=scheduled-scaler

Use Case 5: AWS SQS Queue Processing mit ScaledJob

AWS SQS Nachrichten mit Batch-Jobs bearbeiten:

# Create ClusterTriggerAuthentication with AWS IAM
kubectl apply -f - <<EOF
apiVersion: keda.sh/v1alpha1
kind: ClusterTriggerAuthentication
metadata:
  name: aws-credentials
spec:
  podIdentity:
    provider: aws-eks
EOF

# Create ScaledJob for SQS processing
kubectl apply -f - <<EOF
apiVersion: keda.sh/v1alpha1
kind: ScaledJob
metadata:
  name: sqs-processor
spec:
  jobTargetRef:
    template:
      spec:
        containers:
        - name: processor
          image: my-sqs-processor:latest
          env:
          - name: QUEUE_URL
            value: https://sqs.us-east-1.amazonaws.com/123456789012/my-queue
        restartPolicy: Never
  pollingInterval: 30
  maxReplicaCount: 10
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 3
  triggers:
  - type: aws-sqs-queue
    authenticationRef:
      name: aws-credentials
      kind: ClusterTriggerAuthentication
    metadata:
      queueURL: https://sqs.us-east-1.amazonaws.com/123456789012/my-queue
      queueLength: '5'
      awsRegion: us-east-1
EOF

# Monitor job creation
kubectl get scaledjob sqs-processor
kubectl get jobs -l scaledjob.keda.sh/name=sqs-processor
kubectl logs job/<job-name>

oder Best Practices

• **Start mit konservativen Limits*: Beginnen Sie mit minReplicaCount: 1 und moderaten maxReplicaCount_ Werten. Testwaage-to-zero (minReplicaCount: 0_) erst nach der Validierung Ihrer Anwendungshandgriffe beginnt kalt anmutig.

• **Configure Appropriate Polling and Cooldown*: Set pollingInterval (default 30s) basierend auf der Updatefrequenz Ihrer metrischen Quelle. Verwenden Sie länger cooldownPeriod (Standard 300s) für Workloads mit variablem Verkehr, um Klappen zu verhindern.

• **Use TriggerAuthentication for Secrets*: Nie Hardcode-Anmeldeinformationen in ScaledObject-Spezifikationen. Verwenden Sie immer TriggerAuthentication oder ClusterTriggerAuthentication mit Kubernetes Geheimnissen oder Pod Identity Providern (AWS IAM, Azure AD, GCP Workload Identity).

• **Implementieren Sie HPA Verhaltenspolitik*: Für Produktions-Workloads konfigurieren Sie advanced.horizontalPodAutoscalerConfig.behavior, um Skalierungs-Up/Skala-Down-Raten zu steuern. Verhindern Sie aggressive Skalierung mit Stabilisierungsfenstern und prozentualen Politiken.

Monitor KEDA Komponenten: KEDA-Operator und Metrikserver mit mindestens 2 Repliken für hohe Verfügbarkeit bereitstellen. Aktivieren Sie Prometheus-Überwachung und Alarmierung für KEDA-Komponenten-Gesundheits- und Skalierungsausfälle.

• **Set Resource Limits*: Bestimmen Sie immer Ressourcenwünsche und -limits für beide KEDA-Komponenten und skalierte Workloads. Dadurch wird Ressourceninhalt verhindert und ein vorhersehbares Skalierverhalten gewährleistet.

• **Use Fallback Configuration*: Konfigurieren __INLINE_CODE_89_ und fallback.failureThreshold, um die Verfügbarkeit von Diensten zu gewährleisten, wenn externe metrische Quellen nicht verfügbar sind. Dies verhindert eine Skalierung auf Null bei metrischen Quellenausfällen.

• Test Scaling Behavior: Vor der Produktionseinführung testen Sie die Skalierung unter Last mithilfe der Pausenannotation (INLINE_CODE_91__), um Triggerschwellen zu validieren und Skalierungsmuster zu beobachten, ohne den Live-Verkehr zu beeinflussen.

• Namespace Isolation: Verwenden Sie separate Namespaces für verschiedene Umgebungen (dev, staging, prod) und wenden Sie entsprechende RBAC-Richtlinien an. Verwenden Sie ClusterTriggerAuthentication für gemeinsame Anmeldeinformationen über Namensräume.

• Version Control Scale Objekte: Speichern Sie alle KEDA-Ressourcen in Git zusammen mit Anwendungs manifesten. Verwenden Sie GitOps-Werkzeuge (ArgoCD, Flux), um KEDA-Konfigurationen zu verwalten und Konsistenz in allen Umgebungen sicherzustellen.

Fehlerbehebung

Issue	Solution
ScaledObject not creating HPA	Check KEDA operator logs: INLINE_CODE_93. Verify scaleTargetRef points to existing deployment/statefulset. Ensure deployment has valid selector labels.
Pods not scaling to zero	Verify INLINE_CODE_94 is set. Check if HPA exists: INLINE_CODE_95. Ensure no other HPAs target the same deployment. Review trigger conditions: INLINE_CODE_96.
Metrics not available	Check metrics server: INLINE_CODE_97. View metrics server logs: INLINE_CODE_98. Verify trigger authentication is configured correctly.
Authentication failures	Verify secret exists: INLINE_CODE_99. Check TriggerAuthentication references correct secret and keys. For pod identity, ensure service account has proper IAM/Azure AD annotations. Test credentials manually.
Skalieren zu aggressiv/lang	Adjust pollingInterval (wie oft werden Metriken überprüft). Konfigurieren H