Examples

See what a small AWS application stack looks like with Atmos end to end — backend provisioning, secrets, identities, and Terraform against a local AWS emulator.

Minimal Atmos setup with a single component and three environments — no cloud credentials or access required.

Demonstrates how stores authenticate using Atmos auth identities instead of the default credential chain.

A composition defines a reusable slice of a stack across environments. The top-level compositions: section declares every service that can belong to the slice, while each stack fulfills the subset it…

This example demonstrates Atmos config profiles - a powerful feature for managing environment-specific configurations without duplicating settings across your infrastructure.

Structure an Atmos project with an auth section in atmos.yaml — list providers and identities without contacting real cloud APIs.

Compute stack names from context values with a name template, and inspect how Atmos resolves configuration from multiple sources.

This example demonstrates how to use atmos env to export environment variables for Terraform providers that authenticate via environment variables.

Validate YAML files against JSON Schemas from three sources — a local file, a remote URL, and an inline schema — before anything runs.

Inherit shared component defaults from a catalog and override them per environment — the pattern that eliminates copy-pasted stack config.

Reduce repetition and build computed values using file-scoped locals.

Declarative secrets backed by 1Password, resolved with the !secret YAML function and the atmos secret CLI.

This example demonstrates how to import stack configurations from remote sources using go-getter URL schemes.

Declare, encrypt, and read secrets with a SOPS backend (age encryption) — the full lifecycle against a git-committed encrypted file, no cloud credentials.

Name stacks imperatively with the name field — the explicit name always wins over filenames, templates, and patterns.

This example demonstrates the Terraform registry cache — transparent provider and module caching behind a single flag — and eager multi-platform pre-seeding of providers via atmos terraform cache…

This example demonstrates the container component kind: stack-scoped, Atmos-native, persistent containers. One component is one service. Atmos owns the image artifact (build/push/pull) and a…

This example demonstrates how to define custom component types in Atmos using custom commands.

Pin components to specific versions for reproducible deployments.

Here are some examples of distributing reusable components as part of a library.

Pull Terraform modules from GitHub, S3, or OCI registries with pinned versions.

This example demonstrates migrating from native Terraform (with .tfvars files) to Atmos.

Demonstrates JIT (Just-in-Time) source provisioning from both local and remote sources.

This example runs Terraform tests (*.tftest.hcl) against a local AWS sandbox — no AWS account or credentials required. The apply run blocks in a Terraform test normally create real infrastructure, so…

Deploy Kubernetes resources using Helmfile with Atmos stack patterns, against a local Kubernetes emulator (k3s).

Use the built-in atmos git commands to clone a deployment repository and review its changes by name. In a GitOps pipeline, you can then commit and push generated manifests for Argo CD or Flux to…

A minimal, credential-free example of a native Helm component. The chart lives in components/helm/demo and is configured by stacks/deploy/dev.yaml.

Deploy Kubernetes manifests with Atmos-native Kubernetes components against a local Kubernetes emulator (k3s).

Render and deploy Kustomize overlays with Atmos-native Kubernetes components against a local Kubernetes emulator (k3s).

This example shows how to start a long-running container service in the background, run work against it, and tear it down — all from a workflow.

Build, push, and run containers from Atmos workflows and custom commands.

Extend the Atmos CLI with custom commands defined in atmos.yaml — arguments, flags, nested subcommands, and shell steps.

Minimal Atmos setup demonstrating how stack variables are passed to Ansible playbooks.

Generate Atlantis configuration for PR-based Terraform automation.

Run multiple Atmos commands in sequence with a single command.

This example demonstrates how to use atmos terraform generate files to generate an entire Terraform component from stack configuration.

This example demonstrates Atmos's powerful interactive workflow step types. These step types enable building sophisticated CLI wizards and interactive deployment pipelines.

Minimal Atmos setup demonstrating the Packer component type using Packer's Docker builder — no cloud credentials required.

This example demonstrates parallel and matrix workflow control steps with needs, configurable output, and failure behavior.

Add text-to-speech (TTS) announcements to workflows, custom commands, and lifecycle hooks while still printing deterministic output in headless runs.

One catalog of external versions, two independent environment tracks across three real ecosystems, and a stack that reads locked versions straight into component vars.

Demonstrates automatic retry configuration for workflow steps.

Demonstrates the checkov hook kind: an after.terraform.plan hook that runs checkov against the component and renders a SARIF findings summary in the terminal.

Demonstrates the generic kind: command hook by wiring a custom Python script as an after.terraform.plan hook — the pattern for anything Atmos doesn't ship a named kind for.

Demonstrates the infracost hook kind: an after.terraform.plan hook that runs an Infracost-compatible command against the component and renders a cost summary in the terminal.

Demonstrates the kics hook kind: an after.terraform.plan hook that runs kics scan against the component and renders the SARIF findings summary in the terminal.

Demonstrates the trivy hook kind: an after.terraform.plan hook that runs trivy config against the component and renders a SARIF findings summary in the terminal.

This example demonstrates the http workflow step type, which performs an HTTP request with a configurable method/verb, query-string parameters, headers, and a request body (raw or form/JSON).…

Manage a Terraform state backend directly with atmos terraform backend — create, update, and delete the S3 bucket that stores a component's state, independent of any terraform apply.

Learn how to use the AWS emulator with Atmos — declare it as a stack component and Atmos starts, binds, and stops it around your Terraform runs.

This example deploys a Helm release (nginx) to a local Kubernetes sandbox — no EKS, no cloud, no aws eks update-kubeconfig. The sandbox is an Atmos emulator component running k3s: a stack-scoped…

Stand up an entire GitOps loop on your laptop — no GitHub account, no real cluster, no cloud credentials — and watch a change travel all the way around:

Use AI to chat with your infrastructure, inspect stacks and components, and analyze command output.

Use your Claude Pro/Max subscription instead of API tokens. Claude Code manages the AI conversation — Atmos provides MCP server orchestration with automatic AWS credential injection.

Connect Atmos to external MCP servers from the AWS ecosystem. Their tools become available in atmos ai chat, atmos ai ask, and atmos ai exec — no custom integration code needed.

Configure MCP servers (Atmos MCP server plus the AWS MCP server suite) once in atmos.yaml, then use the same set of tools — with the same AWS credentials managed by Atmos Auth — from Claude Code,…

Run an entire Atmos workflow inside one shared container sandbox.

This example demonstrates how to configure devcontainers in Atmos as a replacement for the Geodesic shell wrapper.

This example demonstrates using a custom Dockerfile with Atmos devcontainers. The Dockerfile extends the Geodesic base image and pre-installs Atmos.

Bootstrap a brand-new Atmos project from a built-in template in one command — no existing atmos.yaml required.

Concrete, ready-to-run scaffold templates — the same catalog atmos init pulls from.

This example demonstrates Atmos's automatic secrets masking feature.

Define the tool versions your stacks and infrastructure depend on — registries, aliases, and pinned versions that Atmos installs on demand.

Scaffold templates for generating new Atmos projects and components.

Duplicate an entire directory's worth of files once per selection, instead of hand-maintaining a near-duplicate directory per environment.

Generate one file per selection instead of hand-maintaining a pile of near-duplicate files.

Demonstrates the tflint hook kind: a before.terraform.init hook that lints a component with tflint and renders a SARIF findings summary in the terminal.

Demonstrates the tfmigrate hook kind. This hook runs a Terraform state migration through atmos terraform migrate before Terraform plan and apply operations.

Extends hooks-tfmigrate to cover the rest of tfmigrate's migration actions and both explicit hook modes. That example, and this repository's automated tests, do not exercise any of these:

Load a shared reference table once from a local file via !include, instead of hand-duplicating the same list of choices across fields or re-deriving the same lookup data in every file that needs it —…

Define prerequisites for custom commands and workflows so Atmos runs them in dependency order. This example also demonstrates reusing identical dependencies, checking input freshness, and skipping…

This example lets app consume vpc's output either from real Terraform state or from a component-owned mock.

Use test steps in custom commands to run checks and report their results. Run these commands from this directory. No cloud credentials or deployment are needed.