helm-me

Warning

helm-me is currently in beta. Core workflows are usable, but the CLI surface, YAML schema, Python DSL, and some generated output details may still change significantly between releases.

Define, deploy, and operate Kubernetes apps with a fast, developer-friendly workflow.

helm-me is aimed at developers who want to ship prototypes and internal apps to Kubernetes quickly, without spending more time on chart authoring than on the application itself. It provides a simple app spec in YAML or Python, operational commands for day-2 work, and a path to export a Helm chart when the project grows up.

helm-me sits between raw manifests, repetitive kubectl command sequences, and full Helm chart authoring. It focuses on developer experience: simple app definitions, fast deploys, convenient shell/log/copy workflows, and compatibility with Helm-oriented environments.

Why use it

• Write one app spec instead of hand-maintaining multiple Kubernetes manifests.
• Choose YAML for simple config-driven setups or Python for typed, parameterized specs.
• Use built-in components for web, postgresql, redis, and deploy hooks.
• Import existing deployments and manage them through the same CLI.
• Work with local dev clusters (kind, minikube, k3d) without pushing images first.
• Avoid memorizing long kubectl command sequences for common day-2 tasks.
• Keep moving fast during prototyping, then export to a Helm chart when you need a more standard handoff.

What problem does it solve?

For many small and medium projects, the first Kubernetes deployment is blocked less by the app itself and more by surrounding work:

• writing and maintaining Helm charts
• wiring together repetitive manifests
• remembering operational kubectl commands
• dealing with awkward workflows around minimal or distroless containers

helm-me tries to make Kubernetes feel like a higher-level application workflow: define the app once, deploy it quickly, inspect it with one CLI, and keep an upgrade path to Helm when needed.

When to use it

Use helm-me when:

• you want a simpler app workflow on Kubernetes
• you want to deploy prototypes, internal tools, demos, chats, APIs, or frontend apps quickly
• you want one tool for both deploys and common operational commands
• you want YAML for simple cases and Python when you need parameters or reuse
• you want a path to export a Helm chart later instead of writing one first

Avoid helm-me when:

• you specifically need the full Helm chart packaging and authoring model from day one
• you want GitOps reconciliation to be the primary operating model

Quick Start

Create a minimal deploy.yaml:

apiVersion: helm-me/v1alpha1
kind: Application
metadata:
  name: hello-app

components:
  backend:
    type: web
    image: traefik/whoami:latest
    port: 80

Validate, preview, and deploy:

helm-me lint deploy.yaml
helm-me render deploy.yaml
helm-me deploy deploy.yaml --namespace demo --yes

Check that it's running:

helm-me ops pods hello-app
helm-me ops logs backend hello-app --tail 50
helm-me ops port-forward backend 8080 hello-app

For the full guide, see Your First App.

Common Tasks

Task	Command
Validate a spec	helm-me lint deploy.yaml
Print rendered manifests	helm-me render deploy.yaml
Deploy an app	helm-me deploy deploy.yaml --yes
List pods	helm-me ops pods {app}
Show pods, services, ingresses	helm-me ops status {app}
Stream logs	helm-me ops logs {component} {app} -f
Open interactive shell	helm-me ops shell {component} {app}
Run a command in a pod	helm-me ops exec {component} {app} -- {cmd}
Copy files to/from pod	helm-me ops cp {component} {src} {dst}
Forward a port	helm-me ops port-forward {component} {port} {app}
Scale a component	helm-me ops scale {component} {replicas} {app}
Rolling restart	helm-me ops restart {component} {app}
Pause (scale to zero)	helm-me ops pause {component} {app}
Live CPU/memory stats	helm-me ops stats {app}
Select the active app	helm-me app use {app}
Import existing deployment	helm-me app import {name} --namespace {ns}
Generate spec from live app	helm-me app generate-spec {name}
Export Helm chart	helm-me chart export deploy.yaml {dir}

LLM-friendly docs

helm-me publishes an llms.txt index for tools and coding agents. For a short human-readable overview of that file, see LLM index.

Which Format?

	YAML	Python
Simplicity	✅ Declarative JSON-like	Requires Python knowledge
Type hints	❌	✅ IDE autocomplete
Dynamic config	❌ Static values only	✅ param() reads env vars
Best for	Simple apps, CI/CD	Complex apps, shared defaults

Learn more in Python vs YAML.

FAQ

Is this a Helm replacement? : No. helm-me is better understood as a higher-level application workflow for teams that do not want to start with chart authoring. It can still fit Helm-oriented environments and can export a chart when needed.

Why not just use raw manifests or kubectl? : You can, but many teams lose time on repeated YAML structure, long operational commands, and ad hoc workflows around shell access, copying files, logs, and port-forwarding. helm-me tries to make those common tasks easier and more consistent.

Why not just start with Helm? : For mature platforms, Helm is often the right end state. But for prototypes, internal tools, demos, and fast-moving apps, chart authoring can become heavier than the app itself. helm-me is meant to reduce that early overhead without blocking a later move to Helm.

Which namespace will be used? : If the spec sets namespace, that value is used. Otherwise, the app name is used. --namespace flag overrides both. See Cluster Configuration.

How do I target another cluster? : Pass --kubeconfig, --context, and --namespace. Or save defaults in .helm-me.toml.

Can I manage apps not deployed by helm-me? : Yes. Use helm-me app import with a label selector.

How do secrets work? : See Secrets & Environment for inline secrets, secret references, and service references.

Can I export a Helm chart? : Yes. See Helm Chart Export.