☁️ DevOps &amp; Cloud

Horizontal Pod Autoscaler (HPA): Scale on Demand

A Horizontal Pod Autoscaler (HPA) is a thermostat for your app's capacity, adding or removing pods based on load. It's used to handle traffic spikes by watching metrics like CPU, but a common footgun is setting aggressive thresholds that cause flapping.

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.

Kubernetes Node: The Cluster's Worker Machine

A Kubernetes Node is a physical or virtual machine that runs Pods. The control plane manages the cluster; node components run the assigned workloads. A Node is the machine, while a Pod groups one or more containers that run together.

Kubernetes Control Plane: The Cluster's Brain

The Kubernetes control plane is the cluster's brain, making all global decisions like scheduling pods and responding to events. You interact with it via kubectl to manage your applications. The footgun: never run your own workloads on control plane nodes.

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.

Cloud Native Buildpacks: No More Dockerfiles

Cloud Native Buildpacks turn source code into container images without a Dockerfile. This lets platform teams enforce security and best practices, while app developers just push code. The footgun is assuming they're simple; they're a full build system.

.ebextensions: Infrastructure as Code for Elastic Beanstalk

.ebextensions are config files for customizing the AWS resources in your Elastic Beanstalk environment. Use them to install packages, run commands on instances, or provision related AWS resources.

Immutable Deployments: Treat Servers Like Cattle, Not Pets

Treat servers like cattle, not pets. Instead of modifying live servers, you deploy updates by replacing entire server fleets with new, pre-baked images. This eliminates configuration drift and simplifies rollbacks.

Promoting Code with Pipeline Stages

Think of pipeline stages as quality gates. Code must pass one gate, like 'build', before being promoted to the next, like 'deploy to staging'. This is core to CI/CD, moving code safely from dev to production. The footgun is making later stages less strict.

Rolling Updates: Deploying Code Without Downtime

A rolling update deploys new code by gradually replacing old application instances with new ones, ensuring zero downtime. It's the default for stateless services in orchestrators like Kubernetes.

AWS CodeDeploy: Automated, Safe Application Updates

AWS CodeDeploy automates pushing your application to servers, Lambda, or ECS. It handles complex updates across many targets, letting you release new features rapidly while minimizing downtime.

AWS CodeBuild: Managed Builds Without the Servers

Think of AWS CodeBuild as an on-demand build server you don't manage. It's used in CI/CD to compile code, run tests, and create artifacts. The main footgun is thinking it's a full CI/CD platform; it's just the 'build' step, needing an orchestrator.

AWS CodePipeline: Your CI/CD Orchestrator

AWS CodePipeline is an orchestrator for your software release workflow, connecting source, build, and deploy stages. It's used to automate continuous delivery, triggering actions on every code change. The footgun: it only *manages* the pipeline.

The Twelve-Factor App: A Blueprint for Portable Cloud Apps

The Twelve-Factor App is a blueprint for building portable, resilient cloud apps. It's used for microservices or apps on platforms like Kubernetes, ensuring they can be easily deployed and scaled. The footgun is treating it as dogma, not a guide.

Procfile: Declare Your App's Startup Commands

A Procfile is the start script for your cloud app, telling the platform what commands to run. You use it to define processes like a web server for HTTP traffic or workers for background jobs.

AWS Elastic Beanstalk: Your App, Not Your Servers

Elastic Beanstalk is a PaaS-like wrapper for AWS infrastructure. You upload your code, and it handles provisioning servers, load balancers, and scaling. It's great for standard web apps but its abstraction is leaky; debugging often requires knowing the…

AWS DMS: Automating Database Migrations

AWS DMS automates moving data between databases, not just as a simple data pump. Use it for one-time migrations to the cloud or for continuous replication. The footgun is assuming DMS also converts your schema; for different engines, you must use the Schema…