Devops
294 bites tagged Devops — interview questions with model answers, and 60-second explainers.
Pipeline Triggers: The 'If This, Then That' of CI/CD
Pipeline triggers are the "if this, then that" for automation. They kick off builds on a code push (CI), run tests for a pull request (PR), or execute jobs on a schedule. The footgun: many systems enable triggers on all branches by default, causing unwanted.
Jenkinsfile: Your CI/CD Pipeline as Code
A Jenkinsfile is a text file that defines your entire CI/CD pipeline as code, living in your source control. It automates build, test, and deploy steps. The main footgun is confusing its two syntaxes: Declarative is simpler, while Scripted offers more power.
Artifact Vulnerability Scanning: A Background Check for Code
Artifact vulnerability scanning is a background check for your software's dependencies, catching known security issues before they ship. It's a key CI/CD step, automatically scanning Docker images against databases of known CVEs. The footgun is alert fatigue.
Artifact Promotion: Build Once, Deploy Everywhere
Artifact promotion means you build software once, then deploy that exact same package to every environment. This prevents "it worked in staging" failures caused by rebuilds pulling different dependencies. The footgun is rebuilding per environment.
Test Data Management (TDM): Stop Flaky Tests
Test Data Management (TDM) treats test data like code: versioned, managed, and reliably provisioned to ensure consistent, meaningful tests. This is crucial in CI/CD pipelines where automated tests require repeatable data states.
Smoke Testing: Is This Build Even Worth Testing?
Smoke testing asks: 'Is this build so broken it's not even worth testing?' It's a quick, shallow check of critical functions, run on every new build before more exhaustive QA. The footgun is thinking a passed smoke test means the build is bug-free.
Reproducible Builds: Trust What You Run
A reproducible build guarantees that the same source code always compiles into the exact same binary. This is crucial for verifying that a distributed application wasn't tampered with.
Incremental Build: Develop and Ship Software in Pieces
Incremental builds deliver software in usable chunks, not one big release. This lets you ship value and gather feedback early on large projects. The footgun is poor planning, leading to disconnected features and architectural debt instead of a cohesive…
Make: The Original Task Runner
Make automates tasks by following a recipe in a `makefile`. It intelligently runs only the necessary steps by checking dependencies, saving time during builds. While common for compiling code, it can run any shell command.
Build Artifact: The Packaged Output of a CI Run
A build artifact is the packaged result of a CI run, like a compiled binary or a zipped web app. Pipelines use artifacts to pass this output between stages, from building to testing and deploying.
Git LFS: Versioning Large Files Without Bloating Your Repo
Git LFS replaces large files with text pointers in your repo, storing the actual data on a remote server. This keeps clones fast when versioning videos, datasets, or graphics. Footgun: `git lfs track` only affects new files, not existing ones.
.gitignore: Telling Git What to Ignore
A .gitignore file is a deny-list for your repository, telling Git which files and directories to intentionally leave untracked. Use it to keep build artifacts, log files, and local configs out of your commit history.
Git Commit: A Snapshot, Not a Diff
A Git commit is a permanent snapshot of your entire project, not just the changes. It's a save point containing the full state of all files, linked to the previous commit to form a historical chain.
Idempotency: Safe to Retry Automation
Idempotent automation ensures an operation has the same effect whether run once or many times. This is vital for safely retrying failed CI/CD jobs or configuration scripts. The footgun: thinking it means 'no side effects'.
GitOps: Your Git Repo is the Single Source of Truth
GitOps makes a Git repo the single source of truth for your infrastructure's desired state. An automated process makes production match what's declared in Git, enabling continuous deployment.
Immutable Infrastructure: Treat Servers Like Cattle, Not Pets
Immutable infrastructure means you never modify running servers. To deploy, you replace them with new ones built from a golden image. This is key for CI/CD and autoscaling, ensuring consistency. The footgun is configuration drift from manual, one-off fixes.
Pipeline as Code: Versioning Your Build Process
Treat your CI/CD pipeline not as clicks in a UI, but as a version-controlled file (`Jenkinsfile`) living with your code. This enables automated, reviewable build processes for every branch. The footgun is defining pipelines in the UI, creating a black box.
Canary Release: Test New Code on Real Users, Safely
A canary release is like sending a canary into a coal mine: expose a new version to a small group of users to detect problems before a full rollout. It's used to safely test changes in production by gradually shifting traffic.
Blue-Green Deployment: Zero-Downtime Releases
Run two identical production environments, Blue (live) and Green (new). To deploy, just flip a switch routing traffic to Green. This enables zero-downtime releases and instant rollbacks. The footgun is using DNS for the switch, which can lag due to caching.
Infrastructure as Code: Manage Servers with Code, Not Clicks
Infrastructure as Code (IaC) treats servers and networks like software: defined in files and versioned in Git. It's used to automate cloud resource provisioning on AWS or GCP, ensuring consistent, repeatable environments.
Artifact Repository: Your CI/CD's Private Library
An artifact repository is your CI/CD's private library for build outputs like packages and images. CI pipelines publish artifacts here, and deployment scripts pull from it.
Automated Testing: Catch Bugs Before They Ship
Automated testing is like a robot QA engineer checking every code change instantly. It's the engine of CI/CD pipelines, running tests on every commit to give developers immediate feedback on business risks.
Build Automation: The Engine of CI/CD
Build automation is a repeatable script that turns source code into a runnable application. It's the first step in any CI/CD pipeline, compiling code and running tests. The main footgun is creating brittle scripts that only work on one developer's machine.
App Signing by Google Play: Trust Google with Your Keys
App Signing by Google Play separates your app's identity from the key you use for uploads. Google manages the final, user-facing signing key, which is mandatory for new apps. The footgun is thinking your upload key is the final key; losing it is recoverable.
Get Devops bites daily.
Five a day, five minutes, offline. With quizzes so it sticks.
Open testing — you’ll join as an early tester.