Kubernetes workload energy governance
Power down and restore workloads on schedule. Reduce cloud costs without manual intervention.

---

Why Aura Power?

Most development workloads run 24/7 even though teams only use them 8-10 hours a day. That is 60% wasted compute. Aura Power lets you define when workloads should be on and automatically shuts them down outside those hours.

Problem	Solution
Dev/staging clusters running overnight and weekends	Schedule-based power-off with automatic restore
No visibility into what is off and why	Web panel with real-time status and savings tracking
Fear of accidentally shutting down critical workloads	Guardrails: system namespace protection, ArgoCD/Helm detection, opt-in model
Complex tooling requiring cluster admin access	Web panel with role-based access (no kubeconfig needed)

Features

• Schedule-based governance Define time windows when workloads should be on. Outside those windows, they power off automatically.
• Priority-based conflict resolution Multiple policies can overlap. The highest priority wins. Temporary overrides can supersede policies.
• Guardrails System namespaces are never touched. Workloads managed by ArgoCD, Helm, or Flux are blocked by default (opt-in required).
• Web Panel Real-time dashboard with targets, rules, schedule visualization, metrics, and savings tracking.
• Prometheus + OpenCost integration Real cluster metrics (CPU, memory, nodes) and cost data from OpenCost.
• Split architecture Server (API + Panel) and Controller (Reconciler) run as separate workloads with isolated RBAC.
• CLI Terminal-based operations for scripting and automation.

Architecture

flowchart TD
    Users["Users (Browser / CLI)"]
    Server["aura-power-server\n(API + Panel + Auth)\nStatefulSet"]
    K8s["Kubernetes API\n(CRDs as message bus)"]
    Controller["aura-power-controller\n(Reconciler + Discovery)\nDeployment with leader election"]
    Workloads["Your Workloads\n(Deployments, StatefulSets, CronJobs)"]

    Users --> Server
    Server <-->|"read/write CRDs"| K8s
    K8s <-->|"watch + reconcile"| Controller
    Controller -->|"scale 0 / restore"| Workloads

    style Server fill:#3B82F6,color:#fff,stroke:#1D4ED8
    style Controller fill:#10B981,color:#fff,stroke:#059669
    style K8s fill:#F59E0B,color:#000,stroke:#D97706
    style Workloads fill:#6366F1,color:#fff,stroke:#4338CA

Loading

The server handles user interactions and serves the web panel. The controller runs reconciliation loops and executes power-down/restore actions. They communicate exclusively through CRDs.

Quick Start

Install with Gateway API

helm install aura-power oci://ghcr.io/weauratech/charts/aura-power \
  --namespace aura-system --create-namespace \
  --set server.auth.jwtSecret=$(openssl rand -hex 32) \
  --set server.auth.initialAdmin.password=changeme \
  --set server.prometheus.url=http://prometheus.monitoring.svc:9090 \
  --set server.gateway.enabled=true \
  --set server.gateway.gatewayRef.name=my-gateway \
  --set server.gateway.gatewayRef.namespace=gateway-ns \
  --set server.gateway.gatewayRef.sectionName=https \
  --set "server.gateway.hostnames[0]=power.example.com"

Install with Ingress

helm install aura-power oci://ghcr.io/weauratech/charts/aura-power \
  --namespace aura-system --create-namespace \
  --set server.auth.jwtSecret=$(openssl rand -hex 32) \
  --set server.auth.initialAdmin.password=changeme \
  --set server.prometheus.url=http://prometheus.monitoring.svc:9090 \
  --set server.ingress.enabled=true \
  --set server.ingress.className=nginx \
  --set server.ingress.host=power.example.com \
  --set server.ingress.tls=true \
  --set server.ingress.tlsSecretName=power-tls

Install (local / port-forward only)

helm install aura-power oci://ghcr.io/weauratech/charts/aura-power \
  --namespace aura-system --create-namespace \
  --set server.auth.jwtSecret=$(openssl rand -hex 32) \
  --set server.auth.initialAdmin.password=changeme

Access the Panel

If you configured an Ingress or Gateway API HTTPRoute, access the panel at the hostname you defined:

https://power.int.example.com

For local testing without Ingress:

kubectl port-forward -n aura-system statefulset/aura-power-server 8080:8080

Login with the admin credentials you set during installation.

Create Your First Policy

apiVersion: power.aura.sh/v1alpha1
kind: PowerPolicy
metadata:
  name: dev-off-hours
  namespace: aura-system
spec:
  scope:
    namespaces: [dev, staging]
  schedule:
    desiredState: "on"
    windows:
      - start: "08:00"
        end: "18:00"
        days: [1, 2, 3, 4, 5]
        timezone: "America/Sao_Paulo"
  priority: 10

Workloads in dev and staging will power off outside 08:00-18:00 Mon-Fri.

Opt-In Workloads

# Single workload
kubectl annotate deployment my-app aura.sh/power-eligible=true

# All workloads in a namespace
kubectl annotate namespace dev aura.sh/power-eligible=true

CRDs

Resource	Purpose
PowerPolicy	Recurring schedule for workload governance
PowerTarget	Auto-discovered workload with current state
PowerOverride	Temporary exception with automatic expiration
PowerSchedule	Named schedule definition (reusable)
PowerAuditEvent	Audit trail of all actions taken

Helm Chart

# OCI registry (recommended)
helm install aura-power oci://ghcr.io/weauratech/charts/aura-power

# With custom values
helm install aura-power oci://ghcr.io/weauratech/charts/aura-power -f values.yaml

See charts/aura-power/README.md for full configuration reference.

CLI

Pre-built binaries are available on the Releases page.

# Login to the server
aura-power login --server https://power.int.example.com --username admin

# Check status
aura-power status

# Explain a workload's state
aura-power explain dev/my-deployment

# View savings
aura-power savings

Development

# Prerequisites: Go 1.25+, Node.js 20+, Docker, Helm 3

# Run tests
make test-all

# Build all binaries
make build-all

# Build Docker images
make docker-build

# Lint
make lint

See CONTRIBUTING.md for the full development guide.

How It Works

1. Discovery: The controller scans all namespaces for Deployments, StatefulSets, and CronJobs. Creates a PowerTarget CRD for each.

2. Evaluation: For each target, the engine evaluates all active policies and overrides. The highest-priority rule wins.

3. Execution: If the desired state is "off" and the workload is running, the controller scales it to zero (or suspends CronJobs). The original replica count is stored in a snapshot for restoration.

4. Guardrails: Before executing, the controller checks for blocks: system namespaces, missing opt-in annotation, active HPAs, ArgoCD/Helm/Flux management. Blocked workloads are never touched.

5. Restoration: When the schedule window opens again, the controller restores workloads to their original state using the stored snapshot.

Comparison

Feature	Aura Power	kube-green	CAST AI
Schedule-based power management	Yes	Yes	Yes
Web panel	Yes	No	Yes
Priority-based conflict resolution	Yes	No	No
Temporary overrides	Yes	No	Yes
Guardrails (ArgoCD, Helm detection)	Yes	No	N/A
Role-based access control	Yes	No	Yes
Open source	Yes (Apache 2.0)	Yes (MIT)	No
Self-hosted	Yes	Yes	No
CronJob support	Yes	Yes	N/A
Savings tracking	Yes	No	Yes
Prometheus integration	Yes	No	Yes
CLI	Yes	No	Yes

Community

• Issues for bug reports and feature requests
• Discussions for questions and ideas
• Contributing Guide
• Security Policy
• Code of Conduct

License

Apache License 2.0. See LICENSE for details.

---

Built by Aura Tech