Setup Cost Gates | Docs

What Are Cost Gates?

Cost Gates is a GitHub App that automatically creates pull requests with rightsizing recommendations for your Kubernetes workloads.

How It Works

text

Kubeadapt analyzes usage → Recommendation ready → Bot creates PR → Team reviews → Merge → Optimization applied

Key Features

GitOps-First Approach:

All changes trackable and auditable through Git
No direct kubectl apply calls to clusters
Infrastructure teams maintain complete control

Intelligent Throttling:

Prevents PR spam with configurable rules
Per-deployment throttling (multiple workloads can have PRs simultaneously)
PR grouping (updates existing PR instead of creating duplicates for maintainability)

Flexible Actions:

autopr: Create PR, require manual review (default)
automerge: Auto-merge PRs automatically

Prerequisites

Before setting up Cost Gates, ensure you have:

Kubeadapt cluster connected with active monitoring
GitHub repository for your Kubernetes manifests (YAML files)
Admin access to install GitHub Apps
GitOps workflow (Argo CD, Flux, or manual kubectl apply from Git)

Supported Platforms:

GitHub
GitLab (coming soon)

Step 1: Install Kubeadapt GitHub App

Cost Gates operates as a GitHub App that monitors your repository.

Install App

Navigate Kubeadapt Github App
Click "Install"
Select repositories:
- All repositories (if you manage multiple clusters)
- Only select repositories (recommended: choose repos with K8s manifests)
Click "Install & Authorize"

Onboarding

After installation, the bot automatically:

Creates onboarding PR with .github/kubeadapt.yaml
Scans repository for tracking comments
Validates configuration and posts status in PR description

Review the onboarding PR:

Check default throttling settings
Adjust configuration if needed
Merge to activate the bot

Step 2: Add Tracking Comments

To track a workload, add inline tracking comments next to resource values in your YAML files.

Why Inline Comments?

Inline comments work with any YAML structure:

Helm chart values.yaml
Kustomize overlays
Plain Kubernetes manifests
Custom template structures

Basic Format

yaml

resources:
  requests:
    cpu: "1" # kubeadapt.io/cluster=prod,deployment=api-server,resource=cpu
    memory: "2Gi" # kubeadapt.io/cluster=prod,deployment=api-server,resource=memory

Full Format with Limits and HPA

yaml

resources:
  requests:
    cpu: "2" # kubeadapt.io/cluster=prod,deployment=api-server,resource=cpu
    memory: "4Gi" # kubeadapt.io/cluster=prod,deployment=api-server,resource=memory
  limits:
    cpu: "4" # kubeadapt.io/cluster=prod,deployment=api-server,resource=cpu-limit
    memory: "8Gi" # kubeadapt.io/cluster=prod,deployment=api-server,resource=memory-limit

minReplicas: 3 # kubeadapt.io/cluster=prod,deployment=api-server,hpa=min
maxReplicas: 10 # kubeadapt.io/cluster=prod,deployment=api-server,hpa=max

Comment Attributes

Required:

cluster: Cluster name in Kubeadapt (e.g., prod, staging)
deployment: Workload name
resource: Resource type - cpu, memory, cpu-limit, memory-limit OR hpa: min, max

Note: Namespace, controller type (Deployment/StatefulSet/DaemonSet), and action (autopr/automerge) are configured in .github/kubeadapt.yaml using path patterns and environment overrides

Step 3: Configure Throttling & Auto-Merge

Edit .kubeadapt/config.yaml to customize bot behavior.

Example Configuration

yaml

version: "1.0"

# Throttling prevents PR spam
throttling:
  min_interval: "24h" # Min time between PRs for same deployment
  min_cost_impact: 25.0 # Min $25/month savings required
  min_percentage_gain: 5.0 # Min 5% improvement required
  max_concurrent_prs: 10 # Max 10 open PRs across all deployments

# Auto-merge settings
auto_merge:
  enabled: false # Enable auto-merge globally
  require_approval: true # Require human approval before merge
  wait_time_after_merge: "1h" # Cooldown period after merge

# Periodic check schedule (cron format)
schedule: "0 9 * * 1" # Every Monday at 9 AM

# Environment-specific overrides
environments:
  - name: production
    cluster_id: prod
    path_patterns:
      - "k8s/production/**"
    auto_merge: false # Conservative for prod

  - name: staging
    cluster_id: staging
    path_patterns:
      - "k8s/staging/**"
    auto_merge: true # Aggressive for staging

Configuration Profiles

Conservative (Production):

yaml

throttling:
  min_interval: "7d" # Weekly max
  min_cost_impact: 100.0 # Significant savings only
  min_percentage_gain: 15.0 # Substantial improvements
  max_concurrent_prs: 3 # Limited PRs

Aggressive (Staging):

yaml

throttling:
  min_interval: "12h" # Twice daily
  min_cost_impact: 5.0 # Any savings
  min_percentage_gain: 2.0 # Small improvements OK
  max_concurrent_prs: 20 # Many PRs allowed

Balanced (Recommended):

yaml

throttling:
  min_interval: "24h" # Daily max
  min_cost_impact: 25.0 # Meaningful savings
  min_percentage_gain: 5.0 # Reasonable improvements
  max_concurrent_prs: 10 # Moderate concurrency

Step 4: Track Your Workloads

Add tracking comments to your Kubernetes manifests.

Example 1: Helm Chart Values (Auto-PR)

yaml

# values.yaml for api-server
replicaCount: 3

image:
  repository: myapp
  tag: latest

resources:
  requests:
    cpu: "1" # kubeadapt.io/cluster=prod,deployment=api-server,resource=cpu
    memory: "2Gi" # kubeadapt.io/cluster=prod,deployment=api-server,resource=memory

Configuration in .github/kubeadapt.yaml:

yaml

environments:
  - name: production
    cluster_id: prod
    path_patterns:
      - "helm/api-server/values.yaml"
    action: autopr # Default: create PR, require review

Result: Bot creates PRs automatically when recommendations are available and met threshold criterias.

Example 2: Kustomize Overlay with Auto-Merge

yaml

# overlays/production/postgres-patch.yaml

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
  namespace: database
spec:
  template:
    spec:
      containers:
        - name: postgres
          resources:
            requests:
              cpu: "2" # kubeadapt.io/cluster=prod,deployment=postgres,resource=cpu
              memory: "4Gi" # kubeadapt.io/cluster=prod,deployment=postgres,resource=memory
            limits:
              cpu: "4" # kubeadapt.io/cluster=prod,deployment=postgres,resource=cpu-limit
              memory: "8Gi" # kubeadapt.io/cluster=prod,deployment=postgres,resource=memory-limit

Configuration in .kubeadapt/config.yaml:

yaml

environments:
  - name: production-database
    cluster_id: prod
    path_patterns:
      - "overlays/production/postgres-patch.yaml"
    action: automerge

Result: Bot creates and auto-merges PRs automatically.

Step 5: Understand PR Format

When a recommendation is ready, the bot creates a PR.

PR Structure

Title: chore(ci): rightsize <Type>/<name> resources

Examples:

chore(ci): rightsize Deployment/api-server resources
chore(ci): rightsize StatefulSet/postgres resources

Branch: kubeadapt/<type>/<deployment-name>

PR Description includes:

Current vs. recommended resources
Cost impact (monthly savings)
Safety analysis
Interactive controls (checkboxes)

Interactive PR Controls

Bot includes Renovate-inspired controls:

Checkbox Commands:

markdown

- [ ] If you want to rebase/retry this PR, check this box

Check the box → Bot rebases PR onto latest base branch

Slash Commands:

/rebase - Rebase PR onto latest base
/recreate - Close and recreate PR with fresh analysis
/skip - Close PR without merging

Throttling Behavior

Throttling prevents PR spam while ensuring important optimizations aren't missed.

Per-Deployment Throttling

Key Principle: Throttling applies per-deployment, not globally.

Allowed: 5 PRs open simultaneously for different deployments
Blocked: 2 PRs for the same deployment within 24 hours (Kubeadapt can generate 1 or 2 recommendation depending on the spike trend)

Throttling Checks

Check 0: Concurrent Limit (Global)

Max 10 open PRs across all deployments

Check 1: Time Interval (Per-Deployment)

Min 24h between PRs for same deployment

Check 2: Cost Impact

Savings must exceed $25/month

Check 3: Percentage Gain

Improvement must exceed 5%

Example Scenario

yaml

# Repo tracks 3 deployments

Deployment A: Last PR 12h ago  → New rec: $50/mo → BLOCKED (< 24h)
Deployment B: Last PR 3d ago   → New rec: $30/mo → ALLOWED
Deployment C: Last PR 7d ago   → New rec: $20/mo → ALLOWED

Result: 2 PRs created (B + C), A waits 12 more hours.

PR Grouping

To keep your repository maintainable and avoid PR spam, the bot updates existing PRs whenever possible instead of creating new ones.

How It Works

text

Day 1: Recommendation arrives → $60 savings → Create PR #123

Day 3: New recommendation arrives → $70 savings
       → UPDATE PR #123 (rebase + add new changes)
       → Don't create new PR

Day 5: PR #123 merged ✅
       → Next recommendation creates new PR

Key Principle: The bot prefers updating existing PRs to maintain a clean PR history.

When PRs Are Updated vs. Created

Bot UPDATES existing PR when:

Open PR already exists for the deployment
New recommendation is available

Bot CREATES new PR when:

No open PR exists
Previous PR was merged or closed

Best Practices

1. Use Auto-Merge for Non-Critical Services

Configuration in .kubeadapt/config.yaml:

yaml

environments:
  - name: staging
    cluster_id: staging
    path_patterns:
      - "helm/**"
    action: automerge # Fully automated

Staging environments benefit from automatic optimization.

2. Set Conservative Throttling for Production

yaml

throttling:
  min_interval: "7d" # Weekly max
  min_cost_impact: 50.0 # Significant savings only

3. Different Settings for Different Environments

yaml

environments:
  - name: production
    cluster_id: prod
    path_patterns:
      - "k8s/production/**"
    action: autopr
    auto_merge: false # Manual review required

  - name: staging
    cluster_id: staging
    path_patterns:
      - "k8s/staging/**"
    action: automerge
    auto_merge: true # Fully automated

4. Use Path Patterns for Organization

yaml

environments:
  - name: backend-services
    cluster_id: prod
    path_patterns:
      - "helm/backend/**"
    action: autopr

  - name: job-workers
    cluster_id: prod
    path_patterns:
      - "helm/jobs/**"
    action: automerge