Gke Workload Scaling
Manages scaling for GKE workloads using HPA and VPA. Use when configuring Horizontal Pod Autoscaler (HPA), configuring Vertical Pod Autoscaler (VPA), or applying best practices for GKE workload autoscaling. Do not use for cluster-level autoscaling (Cluster Autoscaler), static cluster sizing, or configuring node-level machine styles directly.
Get the complete skill folder, including its scripts and reference files.
When to use this skill
Use Gke Workload Scaling when an AI agent needs a reusable SKILL.md workflow for this job: Manages scaling for GKE workloads using HPA and VPA. Use when configuring Horizontal Pod Autoscaler (HPA), configuring Vertical Pod Autoscaler (VPA), or applying best practices for GKE workload autoscaling. Do not use for cluster-level autoscaling (Cluster Autoscaler), static cluster sizing, or configuring node-level machine styles directly.
When not to use it
Skip Gke Workload Scaling when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/gke-workload-scaling # Save SKILL.md to ~/.claude/skills/gke-workload-scaling/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/gke-workload-scaling/SKILL.md. For a shared project, commit the folder at .claude/skills/gke-workload-scaling/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Gke Workload Scaling skill for this task: Use Gke Workload Scaling when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
76/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 85/100
- Practical detail
- 76/100
- Source evidence
- 63/100
- Source signals
- 72/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# GKE Workload Scaling
This skill provides workflows and best practices for scaling applications on Google Kubernetes Engine (GKE). It covers manual scaling, Horizontal Pod Autoscaling (HPA), and Vertical Pod Autoscaling (VPA).
## Attribution
**MUST READ**: Before executing any `gcloud`, REST API, or MCP command, you MUST read [Usage Attribution](references/attribution.md). For commands executed directly in the terminal (never in generated scripts, Terraform, or user code), prefix `gcloud` with `CLOUDSDK_METRICS_REQUEST_ATTRIBUTION="agent-skills/1.0 (skill:gke-workload-scaling)"` and append `agent-skills/1.0 (skill:gke-workload-scaling)` to `User-Agent` headers.
## Workflows
### 1. Manual Scaling
Scale a deployment to a fixed number of replicas. Useful for immediate manual intervention or testing.
**Command:**
```bash kubectl scale deployment {deployment_name} --replicas={number} -n {namespace}
# Verify the scale event kubectl get deployment {deployment_name} -n {namespace} ```
### 2. Horizontal Pod Autoscaling (HPA)
Automatically scale the number of pods based on observed CPU utilization, memory utilization, or custom metrics.
**Prerequisites:**
- Metrics Server must be running (enabled by default on GKE). - Containers clearly define resource requests/limits.
**Quick Command:**
```bash kubectl autoscale deployment {deployment_name} --cpu-percent=50 --min=1 --max=10 ```
**Manifest Approach (Recommended):** Use a YAML manifest for version-controlled configuration. See [assets/hpa-example.yaml](assets/hpa-example.yaml) for a template.
```bash kubectl apply -f assets/hpa-example.yaml
# Verify HPA is created and fetching metrics kubectl get hpa ```
**Custom Metrics & External Metrics:** For GKE, the modern and recommended approach for scaling based on Cloud Monitoring metrics (e.g., Pub/Sub queue length) is to use the **External** metric type, which is natively supported by the GKE control plane without requiring the Custom Metrics Adapter. For application-specific metrics exposed via Prometheus, you can use **Google Cloud Managed Service for Prometheus** or the Prometheus Adapter.
### 3. Vertical Pod Autoscaling (VPA)
Automatically adjust the CPU and memory reservations for your pods to match actual usage. This is critical for right-sizing workloads.
**Prerequisites:**
- VPA must be enabled on the cluster. - **Autopilot:** Enabled by default. - **Standard:** Must be enabled manually.
**Enable VPA on Standard Cluster:**
```bash gcloud container clusters update {cluster_name} --enable-vertical-pod-autoscaling --zone {zone} ```
**Update Modes:**
- `Off`: Calculates recommendations but does not apply them. Good for "dry run" analysis. - `Initial`: Assigns resources only at pod creation time. - `Auto`: Updates running pods by restarting them if recommendations differ significantly from requests. - `InPlaceOrRecreate`: Attempts to update Pod resources without recreating the Pod. If in-place update is not possible, it reverts to `Auto` mode (requires GKE 1.34+).
**Example:** See [assets/vpa-example.yaml](assets/vpa-example.yaml) for a configuration template.
## Best Practices
1. **Define Resource Requests:** HPA and VPA rely on accurate resource requests. Always define them in your container specs. 2. **Avoid Metric Conflicts:** Do not configure HPA and VPA to use the same metric (e.g., both CPU). This causes thrashing. - *Typical Pattern:* HPA on CPU, VPA on Memory. 3. **Pod Disruption Budgets (PDBs):** Define PDBs to ensure application availability during scaling events or node upgrades. 4. **HPA Lag:** HPA has a stabilization window (default 5 mins) to prevent rapid fluctuation. 5. **VPA "Auto" Mode Risks:** In "Auto" mode, VPA restarts pods to change resources. Ensure your application handles restarts gracefully (e.g., handles SIGTERM). - *Note:* By default, VPA requires at least 2 replicas to perform evictions (to prevent a situation where the only running replica is evicted, causing downtime). In GKE 1.22+, you can override this by setting `minReplicas` in `PodUpdatePolicy`.
## Rightsizing Workflow
1. Deploy VPA in `Off` mode for 24+ hours 2. Read recommendations: `kubectl describe vpa {deployment_name}-vpa -n {namespace}` 3. Compare `target` values against current `requests` 4. Apply with 20% buffer: `new_request = target * 1.2` 5. Use patch format or update deployment manifest to apply new resource requests
Condition | Recommendation | Risk ----------------------------- | ------------------------------------ | ------ CPU request >5x P95 actual | Reduce to `P95 * 1.2` | Medium Memory request >3x P95 actual | Reduce to `P95 * 1.2` | Medium CPU request >2x P95 actual | Rightsizing with 20% buffer | Low No resource limits set | Add limits to prevent noisy-neighbor | Low
Intended uses
- Use Gke Workload Scaling when this documented workflow matches the task.
Implementation notes
- Define Resource Requests: HPA and VPA rely on accurate resource
- Avoid Metric Conflicts: Do not configure HPA and VPA to use the same
- Typical Pattern: HPA on CPU, VPA on Memory.
- Pod Disruption Budgets (PDBs): Define PDBs to ensure application
- HPA Lag: HPA has a stabilization window (default 5 mins) to prevent
- VPA "Auto" Mode Risks: In "Auto" mode, VPA restarts pods to change
- Note: By default, VPA requires at least 2 replicas to perform
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.