Articles tagged with #DevOps
A curated list of engineering series, deep dives, and notes related to #DevOps.
Vitest Workspaces: Multi-Project Monorepo Test Execution Isolation
Configure Vitest Workspaces for multi-project monorepos using vitest.workspace.ts.
Container Observation and Troubleshooting: Logging Drivers, Health Checks, and Diagnostics
Master container observation and debugging: HEALTHCHECK instructions, logging drivers, log rotation, docker inspect, docker stats, and deadlock diagnosis.
Production Debugging and Operations: Event Loops, Pending Pods, and OOMKilled Analysis
Master production Kubernetes debugging: Pod failure states (Pending, CrashLoopBackOff, OOMKilled), event inspection, previous container logs, and finalizers.
Spring Boot Externalized Configuration, Profiles, and Production Observability
Master Spring Boot configuration hierarchy, relaxed property binding, profile management, and production health probes with Spring Boot Actuator.
Operating Production Databases: High Availability Replication & Connection Pooling
Learn how to operate production databases: MySQL binary logging formats (RBR/SBR), GTIDs, semi-synchronous replication, and HikariCP connection pooling.
Container Hardening: Non-Root Execution, Linux Capabilities, and Read-Only Filesystems
Master container security hardening: Non-root USER execution, Linux capability dropping (--cap-drop=ALL), read-only filesystems, and user namespaces.
Extending Kubernetes: Custom Resource Definitions (CRDs) and the Operator Pattern
Master Kubernetes extensibility: Custom Resource Definitions (CRDs), OpenAPI v3 schemas, Custom Controllers, and the Operator Pattern.
Multi-Container Orchestration: Docker Compose Architecture and Declarative Configs
Master multi-container orchestration with Docker Compose: declarative specs, service networks, volumes, and depends_on health check readiness sequencing.
Cluster Security & Authorization: RBAC, ServiceAccounts, and Admission Webhooks
Master Kubernetes security: Authentication (ServiceAccounts), RBAC Authorization (Roles, RoleBindings), and Admission Webhooks.
Docker Storage Options: Named Volumes, Bind Mounts, and tmpfs Mount Mechanics
Master Docker storage strategies: Named Volumes, Host Bind Mounts, tmpfs in-memory mounts, and kernel mount namespace mechanics.
Kubernetes Scheduler Internals: Filtering (Predicates), Scoring (Priorities), and Affinities
Master kube-scheduler internals: Filtering (predicates), Scoring (priorities), Node/Pod Affinities, Taints & Tolerations, and Image Locality.
Configuration and Secrets Management: ConfigMaps, Secrets, and Volume Mount Mechanics
Master Kubernetes configuration management: ConfigMaps, Secrets, environment variable injection vs volume mount atomic symlink live-reloading.
User-Defined Networks and Embedded DNS Resolution in Docker
Master Docker user-defined bridge networks: embedded DNS at 127.0.0.11, automatic service discovery by container name, and network isolation.
Dynamic Storage Provisioning: PersistentVolumes, PVCs, StorageClasses, and CSI gRPC
Master Kubernetes storage provisioning: StorageClasses, PersistentVolumeClaims (PVCs), PersistentVolumes (PVs), Access Modes, and CSI gRPC calls.
Port Publishing Under the Hood: iptables DNAT, Userland Proxies, and Host Routing
Explore Docker port publishing (-p 8080:80): iptables PREROUTING chains, Destination NAT (DNAT) packet rewriting, and docker-proxy userland socket proxies.
CoreDNS, Service Discovery, and Ingress Controller Architecture
Master Kubernetes service discovery: CoreDNS naming conventions, ClusterIP vs NodePort vs LoadBalancer, Ingress Controllers, and Gateway API.
Container Virtual Networking: Bridge Networks, veth Pairs, and Network Namespaces
Master container virtual networking: Network Namespaces, Virtual Ethernet (veth) pairs, docker0 bridge interfaces, and packet routing.
Service Proxies Under the Hood: Virtual IPs, kube-proxy iptables, and IPVS Routing
Master Kubernetes Service proxies: ClusterIP Virtual IPs, kube-proxy iptables probability rules (-m statistic), IPVS hash tables, and eBPF routing.
Enforcing Container Resource Limits: cgroups v1 vs v2 Memory and CPU Limits
Master container resource limits: cgroups v1 vs v2 architectures, CFS CPU quotas, memory limits, and OOM Killer exit code 137 mechanics.
The Kubernetes Pod Networking Model: Flat IP-per-Pod Networks and CNI Plugins
Master the Kubernetes Pod Networking Model: IP-per-Pod rules, NAT-less cross-node routing, CNI plugin execution, and VXLAN vs BGP overlay encapsulation.
Container Lifecycle and PID 1 Behavior: Signal Propagation and Process Management
Master container process management: PID 1 signal handling defaults, SIGTERM propagation, zombie process reaping, and Tini init process wrappers.
Stateful Workloads: StatefulSets, Stable Network Identities, and Ordered Scaling
Master Kubernetes StatefulSets: Ordinal indexing (pod-0, pod-1), Headless Service DNS identities, dedicated volumeClaimTemplates, and ordered scaling.
Controllers Deep Dive: ReplicaSets, Deployments, and Rolling Update Mechanics
Master Kubernetes workload controllers: Deployment vs ReplicaSet hierarchies, zero-downtime Rolling Updates, maxSurge, maxUnavailable, and instant rollbacks.
Container Registries: Content-Addressable Storage, Push/Pull Protocols, Tags vs Digests
Master container registries: OCI Distribution Spec HTTP API v2, tag mutability vs immutable SHA-256 digests, and layer deduplication.
The Atomic Unit of Scheduling: Why Kubernetes Uses Pods Instead of Containers
Discover why Kubernetes schedules Pods instead of containers: co-location guarantees, shared netns/IPC, sidecars, and init container mechanics.
Multi-Stage Build Architectures & Minimal Base Image Optimization
Master multi-stage Docker builds: build stage pipelines, selective artifact copying, distroless vs Alpine vs scratch base images, and CVE reduction.
Informers, Listers, and the HTTP/2 Watch API: Efficient State Synchronization
Master client-go controller architecture: Reflectors, DeltaFIFO queues, SharedInformers, in-memory Indexers, WorkQueues, and HTTP/2 Watch streams.
Dockerfile Instructions and Layer Mechanics: How Build Caching Works Under the Hood
Master Dockerfile build caching: cache invalidation cascades, COPY content checksums, instruction ordering optimization, and Exec vs Shell forms.
Anatomy of a Docker Image: Layers, Config JSON, and Manifest Specifications
Explore the internal architecture of a Docker image: manifest lists, configuration JSON, tarball layer diffs, and whiteout file mechanics.
Declarative Desired State vs Imperative Commands: The Kubernetes Operating Philosophy
Master the Kubernetes operating philosophy: Imperative vs Declarative configuration, spec vs status field separation, and idempotent state reconciliation.
The Kubelet and Container Runtime Interface (CRI): How Nodes Execute Pods
Explore the Kubelet node agent and Container Runtime Interface (CRI): RuntimeService gRPC methods, PodSandbox creation, and pause container mechanics.
The Open Container Initiative (OCI): Image Specification and Runtime Specification
Master the Open Container Initiative (OCI) standards: Image Spec manifests, configuration JSON, layer diff tarballs, and the Runtime Spec filesystem bundle layout.
The Docker Toolchain Deep Dive: CLI to Daemon to containerd to runc
Explore the internal Docker process architecture: docker CLI, dockerd daemon, gRPC containerd, daemonless containerd-shim, and runc OCI container execution.
Kubernetes Control Plane Architecture: API Server, etcd, Scheduler, and Controller Manager
Master Kubernetes architecture: API Server, etcd distributed storage, Scheduler node placement, Controller Manager loops, and Kubelet node agents.
What Docker Adds on Top of Linux Kernel Isolation Primitives
Discover what Docker built on top of bare Linux namespaces, cgroups, and OverlayFS to create the modern container engine experience.
Why Single-Host Docker Fails at Scale: The Distributed Orchestration Problem
Discover why single-host Docker setups fail at scale: host failure domains, manual port allocation conflicts, stateful failover, and scheduling bottlenecks.
Mastering Docker & Container Internals from First Principles: Series Introduction & Learning Roadmap
Discover what you will learn in this 20-part series on Docker Internals. Build a custom container engine and master Linux isolation primitives.
Mastering Apache Kafka from First Principles: Series Introduction & Learning Roadmap
Discover what you will learn in this 19-part series on Apache Kafka internals. Master distributed append-only logs, zero-copy I/O, and KRaft.
Mastering Kubernetes & Distributed Orchestration: Series Introduction & Learning Roadmap
Discover what you will learn in this 20-part series on Kubernetes Internals. Build a custom Kubernetes Operator and master control plane mechanics.
Mastering System Design & Distributed Systems: Series Introduction & Learning Roadmap
Discover what you will learn in this 20-part series on System Design & Distributed Systems. Build a distributed rate limiter and master Raft.