What Is Immutable Infrastructure?
Learn what immutable infrastructure means, how it prevents configuration drift, and how to explain it clearly in a DevOps interview.
Expected Interview Answer
Immutable infrastructure is a model where servers or containers are never modified after deployment — any change is made by building a new image and replacing the old instance entirely, rather than patching it in place.
Instead of SSHing into a running server to install a package or change a config file, teams bake the desired state into a machine image or container image ahead of time using tools like Packer or a Dockerfile. When an update is needed, a new image is built, tested, and rolled out as fresh instances, while old instances are terminated rather than updated. This eliminates configuration drift, because every running instance is guaranteed to match a known, versioned artifact rather than accumulating undocumented manual changes over time. It also makes rollback trivial, since reverting just means redeploying the previous known-good image.
- Eliminates configuration drift between environments
- Makes rollback as simple as redeploying a prior image
- Every environment is reproducible from version-controlled artifacts
- Reduces "it worked on my machine" class of bugs
AI Mentor Explanation
Immutable infrastructure is like a franchise refusing to patch a damaged cricket bat mid-season and instead handing the batter a brand-new bat built to the exact same certified specification. Rather than sanding down a crack or adding tape, the equipment team retires the old bat entirely and issues a freshly manufactured one from the same verified batch. If the new bat has an issue, they simply swap in another from the identical certified stock rather than trying to repair it on the boundary. This guarantees every bat in use matches a known, tested specification instead of slowly diverging through ad-hoc repairs.
Step-by-Step Explanation
Step 1
Define desired state as code
Package configuration and dependencies into a Dockerfile or machine image template rather than a runbook.
Step 2
Build a versioned image
CI builds a new, immutable, versioned image artifact and stores it in a registry.
Step 3
Deploy fresh instances
New instances are launched from the versioned image; nothing is patched on running instances.
Step 4
Terminate the old
Old instances are drained and destroyed once new ones are healthy, leaving no manually modified servers behind.
What Interviewer Expects
- Clear contrast with mutable, in-place server patching
- Mention of eliminating configuration drift
- Understanding that rollback means redeploying a prior image
- Awareness of tooling: Docker images, Packer, versioned AMIs
Common Mistakes
- Saying it means servers can never change state at runtime (memory/disk writes are fine; the image definition is what is immutable)
- Confusing immutable infrastructure with infrastructure as code (related but not the same)
- Forgetting to mention configuration drift as the core problem being solved
- Not explaining how rollback works under this model
Best Answer (HR Friendly)
“Immutable infrastructure means instead of logging into a server to fix or update it, we build a brand-new version of it from scratch and swap it in. That keeps every environment predictable and consistent, and if something goes wrong, we can just switch back to the previous known-good version instantly.”
Code Example
# Build a new versioned image instead of patching a running server
docker build -t registry.example.com/api:1.4.0 .
docker push registry.example.com/api:1.4.0
# Deploy fresh instances from the new image
kubectl set image deployment/api api=registry.example.com/api:1.4.0
# Roll back by redeploying the previous known-good image
kubectl rollout undo deployment/apiFollow-up Questions
- How does immutable infrastructure eliminate configuration drift?
- What tools are commonly used to build immutable images?
- How does rollback work in an immutable model versus a mutable one?
- What is the relationship between immutable infrastructure and infrastructure as code?
MCQ Practice
1. What is the core principle of immutable infrastructure?
Immutable infrastructure replaces instances entirely with new versioned images rather than patching them live.
2. Which problem does immutable infrastructure primarily solve?
Because servers are never modified in place, every instance matches a known versioned artifact, eliminating drift.
3. How is rollback typically performed in an immutable infrastructure model?
Since every state is captured in a versioned image, rollback is simply deploying the prior image version.
Flash Cards
What is immutable infrastructure? — A model where running servers/containers are never modified in place; changes are deployed as brand-new versioned images.
What problem does it primarily eliminate? — Configuration drift caused by undocumented manual changes to running servers.
How is rollback handled? — By redeploying the previous known-good versioned image instead of undoing live changes.
Name two tools used to build immutable images. — Docker (container images) and Packer (machine images/AMIs).