Devops
294 bites tagged Devops — interview questions with model answers, and 60-second explainers.
The Dockerfile: A Recipe for Your Container
A Dockerfile is a text-based recipe for building a Docker image, specifying the OS, code, and dependencies. You use it to create consistent, portable application environments.
Container Lifecycle: From Create to Remove
A container is a state machine: created, running, paused, stopped, and removed. You manage this with commands like `docker run`, while orchestrators automate it. The footgun: `stop` doesn't delete a container; you must `rm` it to free up disk space.
The 'Works on My Machine' Problem
Code runs on your laptop but fails in production because of hidden differences in environments. Docker solves this by packaging an app and its dependencies into a portable container, ensuring it runs the same everywhere.
Shift-Left Accessibility: Build It In, Don't Bolt It On
Shift-left accessibility treats accessibility as a core feature, not a last-minute fix. It integrates checks throughout the development lifecycle, from design to deployment, preventing costly rework. The footgun is treating it as just an earlier QA step.
Long-Term Support (LTS): Stability Over New Features
LTS is a promise of stability for a specific software version, trading new features for long-term bug fixes and security patches. It's crucial for production systems like Node.js or Ubuntu. The footgun is assuming all bugs get fixed, not just critical ones.
Lead Time for Changes: From Commit to Production
Lead Time for Changes measures the time from a developer's commit to that code running in production. It's a core DORA metric for assessing DevOps velocity. The key footgun is confusing it with 'Lead Time,' which tracks from idea to delivery.
Schema Evolution: Changing a Live Database Without Outages
Schema evolution is like renovating a house while you live in it: you must change your database's structure without breaking the live application. This is critical when adding or renaming columns.
Differential Backups: Faster Backups, Simpler Restores
A differential backup saves all changes since the last full backup, making daily backups faster. To restore, you only need the full backup and the latest differential file. The footgun: each differential file grows larger until the next full backup is made.
Log Aggregation and Parsing: From Chaos to Clarity
Log aggregation gathers scattered system events into one place; parsing turns that raw text into structured, searchable data. This is essential for debugging distributed systems or analyzing security incidents.
CODEOWNERS: Auto-Assigning PR Reviewers
A CODEOWNERS file maps repo paths to owners, auto-requesting their review on PRs. It ensures experts review changes to their code, like a platform team owning CI configs. The footgun: owners aren't notified for draft PRs and must have write permissions.
Cloud Alerting: Your System's Automated Smoke Detector
Cloud alerting is your system's smoke detector, watching key metrics and screaming when something's wrong before it becomes a fire. It's used to flag high CPU, failing health checks, or security anomalies.
Automate Storage Costs with Lifecycle Policies
Object storage lifecycle policies are automated rules that move or delete data as it ages to save money. They're ideal for logs or backups, transitioning them to cheaper "cold" storage over time.
Cloud Landing Zone: A Blueprint for Cloud Environments
A Cloud Landing Zone is a pre-configured, secure foundation for your cloud applications, like a city grid with utilities ready for new buildings. It provides shared services like networking and identity, ensuring consistency for large organizations.
The 6 R's: Your Playbook for Cloud Migration
The 6 R's are a strategic menu for migrating apps to the cloud. When planning a move, you use it to decide whether to simply 'Rehost' an app, 'Refactor' it for performance, or even 'Retire' it.
MLOps: Applying DevOps to Machine Learning
MLOps applies DevOps principles to automate the machine learning lifecycle, creating an assembly line for models. It's for moving from notebooks to production systems that retrain automatically.
Start/Stop Automation: Pay Only For What You Use
Start/stop automation is like putting your cloud resources on a timer to save money. It's essential for non-production environments like dev and staging used only during business hours.
FinOps Framework: Aligning Cloud Cost with Business Value
FinOps treats cloud spend as a business metric, not just an IT cost. It provides a shared framework for engineering, finance, and business to collaborate on data-driven spending decisions.
Policy as Code: Rules as Versioned, Testable Code
Policy as Code (PaC) treats rules like code: versioned, tested, and automated. Instead of manual UI clicks, you define guardrails in a declarative language. Use it in CI/CD to block bad deploys or in Kubernetes to enforce runtime rules.
IaC State: The Map Between Your Code and the Cloud
IaC state is the source of truth mapping your code to real-world resources, acting as your tool's memory. Terraform uses a state file to plan updates, while other tools use a service backend. The footgun: never commit state files to Git; they lack locking and.
Centralized Logging: A Universal Inbox for Your Systems
Centralized logging is a universal inbox for all your system events. Instead of SSHing into each server, agents forward logs to one searchable location, making it possible to debug issues that span multiple services. The footgun is inconsistent log formats.
Managed Kubernetes: Your Cloud's K8s Control Plane
A managed Kubernetes service (EKS, AKS, GKE) runs the complex K8s control plane for you, letting you focus on deploying apps, not managing infrastructure. Use it to run containers without the overhead of maintaining masters.
Kubernetes StatefulSet: Pods with Stable Identity
A StatefulSet gives Kubernetes pods a stable identity and dedicated storage, like assigning a permanent desk and locker to an employee. Use it for databases or clustered apps where nodes need to find each other and retain data across restarts.
Docker Engine: Shipping Your Code in a Standard Box
Think of Docker as a standard shipping container for your code. It packages an app and all its dependencies into one unit that runs anywhere, solving the classic "it works on my machine" problem. The footgun is confusing it with a full VM; it's lighter.
Containerization: Packaging Apps to Run Anywhere
Think of a container as a standardized box for your app, bundling its code and all dependencies. This ensures it runs the same everywhere, solving "it works on my machine" problems. The footgun is confusing them with VMs; containers are less isolated.
Get Devops bites daily.
Five a day, five minutes, offline. With quizzes so it sticks.
Open testing — you’ll join as an early tester.