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 or exact CronJob suspend state 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