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).

This example shows the publishing half of a GitOps pipeline — reconcile, review, and publish artifacts to a managed deployment repository using atmos git. A reconciler such as Argo CD or Flux (or…

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.

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.