Skip to main content

THE ATMOS LIBRARY

Start with an example.

Real configurations. Working infrastructure.
Find a starting point and make it yours.

New to Atmos? Start here

Category

All examples82 examples

Explore the possibilities

Quickstart Featured

Quick Start (Simple)

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

Quickstart Featured

Quick Start (Advanced)

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.

Stacks Featured

SOPS Secrets

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

Toolchain

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

Automation Featured

Custom Commands

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

Emulators Featured

AWS Emulator

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.

Atmos AI

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

AI with Claude Code CLI

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.

Auth Identities for Stores

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

Backend Provisioning

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.

TerraformEmulators

Background Steps

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.

Terraform Registry Cache

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…

CLI-Config Imports

This example demonstrates the string and object forms of the top-level import: list in atmos.yaml, bringing CLI-config imports toward parity with stack-manifest imports.

AWS CloudFormation

Deploy a native aws/cloudformation component — no external binary, no AWS account or credentials required — against a local Floci AWS emulator.

ComponentsEmulators

CloudFormation Build and Publish Pipeline

Build, test, archive, and publish a Python Lambda application, deploy it through CloudFormation, and validate its HTTP response. Everything runs locally in Floci; no AWS account or credentials are…

ComponentsHooksAutomationEmulators

Compositions

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…

Config Profiles

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

Container Components

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…

Container Sandbox

Run an entire Atmos workflow inside one shared container sandbox.

Container Steps

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

Custom Component Types

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

Ansible

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

Atlantis

Generate Atlantis configuration for PR-based Terraform automation.

Authentication

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

Component Versions

Pin components to specific versions for reproducible deployments.

Configuration Context

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

Environment Variables

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

Helmfile

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

Component Library

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

OPA Policy Validation

Enforce component configuration with Open Policy Agent (OPA) policies - block provisioning when a stack violates your rules, before any Terraform runs.

Schema Validation

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

Stack Inheritance

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

Vendoring

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

Workflows

Run multiple Atmos commands in sequence with a single command.

Devcontainer

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

Devcontainer (Custom Build)

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

Kubernetes Emulator

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…

EmulatorsKubernetes

Generate Files

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

TerraformAutomation

GitOps Publishing

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…

KubernetesAutomation

Native Helm

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.

Checkov Hook

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.

Custom Command Hook

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.

Infracost Hook

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.

KICS Hook

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.

TFLint Hook

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.

TFMigrate Hook

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

TFMigrate Hook (Advanced)

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:

Trivy Hook

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.

HTTP Webhooks

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

HooksAutomation

Init

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

Interactive Workflows

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

Kubernetes Components

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

Kustomize

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

GitOps with Flux

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:

KubernetesEmulatorsAutomation

Locals

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

MCP Server Integrations

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.

MCP for AI Coding Assistants

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,…

Native Terraform Migration

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

1Password Secrets

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

Packer + Docker

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

Parallel Steps

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

Per-Store Identity for Planfile Storage

Demonstrates authenticating a planfile store with a specific Atmos auth identity, independent of the component's identity.

Local Policy Walkthrough

Inspect and test a policy, then see it block a destructive command without Terraform or cloud credentials.

Remote Stack Imports

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

Say Something

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

Scaffold Templates

Scaffold templates for generating new Atmos projects and components.

scaffolding-directory-matrix

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

Scaffold Matrix

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

Scaffold YAML Functions

Use YAML functions to load shared data and computed values in scaffold templates.

ScaffoldingYAML Functions

Scaffolds

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

Secrets Masking

This example demonstrates Atmos's automatic secrets masking feature.

Source Provisioning

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

Stack Names

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

starlark-commands

This example defines atmos capacity in atmos.yaml. The command calculates how many workers a service can run and provides a --replicas flag and generated help.

starlark-hooks

Check component ownership before Terraform plans a module using Atmos Automation Language, a Python-like language built on Starlark and embedded in Atmos. The hook reads resolved stack variables…

starlark-script

Build a CLI app that reads a JSON service manifest and reports replica totals. The program is written in the Atmos Automation Language, a Python-like language based on Starlark. Atmos supplies the…

Task Runner Dependencies

Demonstrates the custom-command and workflow task-runner's dependency system: dependencies.commands / dependencies.workflows (DAG execution with dedup), failfast vs besteffort sibling-dependency…

Terraform Component Mocks

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

TerraformComponents

Terraform Tests

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…

tests

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.

Version Tracker

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

Workflow Retries

Demonstrates automatic retry configuration for workflow steps.