A terminal UI that turns any Terraform module into something you can actually use.
If you’ve ever stared at a main.tf that’s 300 lines of commented-out defaults and wondered which ten variables actually matter, you’re not alone. Terraform modules are powerful, but the moment they grow past a handful of inputs, most of them become opaque: the README is stale, the example main.tf dumps every optional variable in, and the only person who truly knows which values to change is whoever wrote it.
Atelier exists to close that gap.
What Atelier does
Atelier is a terminal UI for configuring Terraform modules. Point it at any module, whether from the public registry, a git repo, or a concrete module, and it reads the variable declarations to build an interactive editor. You see every variable, its type, its default, and a clean space to enter the value you care about.
No more copy-pasting example files. No more hunting through variables.tf to find the one thing you need to change. Just a focused, keyboard-driven interface that asks: what do you want to be different from the default?
The wrapper, not the module
Here’s the key idea: Atelier doesn’t modify the upstream module. Instead it generates a thin wrapper, a small main.tf that calls the module with only the values you explicitly set. The rest come from the module’s own defaults.
That wrapper is a first-class artifact. You can version-control it, share it, run terraform plan and terraform apply on it without Atelier installed, and plug it into CI pipelines. Atelier is the thing that makes the wrapper easy to build; the wrapper is the thing that lives on.
See what changes, before you apply
Every time you edit a variable, Atelier runs terraform plan behind the scenes and shows you exactly what the diff looks like: not a wall of Terraform output, but a focused view of what’s being added, changed, or destroyed. If a variable you set matches the module’s default, the wrapper never writes it, so main.tf stays as concise as possible. Press a key to apply right from the plan view, or quit and come back later.
Compare versions without leaving your terminal
Modules evolve. Atelier lets you switch the module ref, whether a tag, a branch, or a commit SHA, without leaving the TUI. It re-fetches the module, carries your values forward, runs terraform init -upgrade, and then re-plans. The diff you see is what the version bump actually changes. That kind of upgrade feedback used to mean manually cloning two copies, diffing their variables.tf, and guessing. Now it’s a keystroke.
Presets for the way you work
If you repeatedly deploy the same module with a known set of values, such as production, staging, or a team sandbox, you can save those as presets in a local YAML file. One keypress loads a preset into the TUI; you can tweak and go. Presets live in your repo, not in the module, so they’re yours to evolve and share with your team.
Designed to be generic
Atelier isn’t tied to any single cloud, any single vendor, or any single Canonical product. If a module declares variable blocks, Atelier can work with it. AWS, GCP, Azure, and private internal modules all show up the same way in the editor.
Quick start guide
If you have installed Atelier and Juju on K8s, try this command:
atelier module add https://github.com/canonical/observability-stack.git --module terraform/cos-lite
╭──────────────────────────────────────────────────────────────────────────────────────────╮
│ Module: cos_lite ·unpinned │
╰──────────────────────────────────────────────────────────────────────────────────────────╯
╭────────────────────────────────╮ ╭───────────────────────────────────────────────────────╮
│ [ ] risk │ │ risk string │
│ [ ] model │ │ Risk level that the applications are (unless │
│ [ ] internal_tls │ │ overwritten by individual channels) deployed from │
│ [ ] external_certificates_of… │ │ │
│ [ ] external_ca_cert_offer_u… │ │ [edge] │
│ [ ] postgresql_offer_url │ │ │
│ [ ] ingress │ │ │
│ [ ] alertmanager │ │ │
│ [ ] catalogue │ │ │
│ [ ] grafana │ │ │
│ [ ] loki │ │ │
│ [ ] prometheus │ │ │
│ [ ] ssc │ │ │
│ [ ] traefik │ │ │
╰────────────────────────────────╯ ╰───────────────────────────────────────────────────────╯
╭──────────────────────────────────────────────────────────────────────────────────────────╮
│ [Tab] pane [↑︎↓︎] navigate [P] plan [F] preset [S] save [R] ref [Q] quit [?] help │
╰──────────────────────────────────────────────────────────────────────────────────────────╯
and press [?] for the help menu to start interacting with the product.
Great, but now what?
This was an introduction, but if you want tangible use cases for Atelier, see the following posts:
- Atelier: Comparing module versions before you upgrade
- Atelier: Rebuilding state from a live deployment
Check out the README for install instructions and the quick-start guide, or dive into the design documentation if you want to understand the contracts and decisions behind it.