IBM DevOps and Software Engineering cheat sheet

DevOps is a cultural and technical movement that unifies software development (Dev) and IT operations (Ops) to shorten delivery cycles and improve quality.

CALMS framework: Culture, Automation, Lean, Measurement, Sharing - core pillars for assessing DevOps adoption.

The Three Ways: (1) flow of work from Dev to Ops, (2) amplify feedback loops, (3) culture of continuous experimentation and learning.

DORA metrics: Deployment Frequency, Lead Time for Changes, Change Failure Rate, Mean Time to Restore (MTTR). Elite performers deploy on demand and restore in under one hour.

Continuous Integration (CI) requires developers to merge into a shared trunk at least daily and verify each merge with an automated build and test.

Continuous Delivery (CD) keeps the main branch always deployable; Continuous Deployment goes further by automatically releasing every passing change to production.

A deployment pipeline is an automated expression of the build-test-release process; each stage should fail fast and provide fast feedback.

Infrastructure as Code (IaC) treats servers, networks, and configuration as versioned source files, enabling repeatable and auditable environments.

Value stream mapping identifies wait states and handoffs; the goal is to reduce lead time, not just optimize individual steps.

Agile Manifesto values: individuals and interactions over processes and tools; working software over comprehensive documentation; customer collaboration over contract negotiation; responding to change over following a plan.

Scrum pillars: transparency, inspection, and adaptation; the empirical process control loop is Plan-Do-Check-Act.

Scrum roles: Product Owner (maximizes value and manages backlog), Scrum Master (servant leader and process coach), Developers (self-managing cross-functional team).

Scrum events: Sprint (fixed length, usually 1-4 weeks), Sprint Planning, Daily Scrum (15 minutes), Sprint Review, and Sprint Retrospective.

Scrum artifacts: Product Backlog, Sprint Backlog, and Increment; each has a Definition of Done that applies to the increment.

A user story follows the format: As a , I want , so that ; acceptance criteria define when it is complete.

Story points estimate relative size using the Fibonacci sequence (1, 2, 3, 5, 8, 13, 21); Planning Poker is a common consensus technique.

Velocity is the average number of story points completed per Sprint; it is used for forecasting, not for comparing teams.

Kanban limits Work in Progress (WIP) to expose bottlenecks and uses cycle time and lead time as primary flow metrics.

Cloud native combines containers, service meshes, microservices, immutable infrastructure, and declarative APIs to build resilient, manageable systems.

The CNCF defines cloud native as technologies that empower organizations to run scalable applications in dynamic environments such as public, private, and hybrid clouds.

Twelve-Factor App principles include codebase, dependencies, config, backing services, build-release-run, processes, port binding, concurrency, disposability, dev/prod parity, logs, and admin processes.

CI/CD tool examples: Jenkins (extensible with plugins), GitLab CI/CD (.gitlab-ci.yml), GitHub Actions (workflows in .github/workflows), CircleCI, and Tekton.

Jenkinsfile uses declarative pipeline syntax with pipeline, agent, stages, stage, steps, and post blocks; the Jenkins controller schedules builds on agents.

Git branching strategies: GitFlow (feature, develop, release, hotfix branches), trunk-based development (short-lived branches, frequent merges), and GitHub Flow (feature branch plus pull request).

A container image is built from a Dockerfile; each instruction creates a read-only layer, and layers are cached to speed up rebuilds.

Immutable infrastructure means servers are replaced rather than modified in place, reducing configuration drift.

Blue-green deployment runs two identical environments and switches traffic; canary releases route a small percentage of traffic to the new version first.

A container packages application code and dependencies into an isolated, portable unit that shares the host OS kernel, unlike a virtual machine which includes a full guest OS.

Docker core objects: image (read-only template), container (running instance), volume (persistent storage), and network (container communication).

Kubernetes architecture: control plane (kube-apiserver, etcd, kube-scheduler, kube-controller-manager) and worker nodes (kubelet, kube-proxy, container runtime).

Kubernetes workload objects: Pod (smallest deployable unit), ReplicaSet (maintains replica count), Deployment (declarative updates and rollbacks), StatefulSet (stable identity and storage), DaemonSet (one pod per node), Job and CronJob (batch tasks).

Service types: ClusterIP (internal), NodePort (exposes on each node's IP), LoadBalancer (cloud load balancer), and ExternalName (DNS alias).

Configuration and secrets: ConfigMap for non-confidential configuration, Secret for sensitive data (base64-encoded, not encrypted by default).

kubectl commands: kubectl get, describe, apply -f, logs, exec -it, port-forward, scale, and rollout undo.

Application modernization paths: rehost (lift and shift), replatform (lift, tinker, and shift), refactor/re-architect (microservices), repurchase (SaaS), and retire.

The strangler fig pattern incrementally replaces legacy functionality with new services while routing traffic through a facade.