
Affinity, anti-affinity and scheduling
Placement rules: keeping workloads apart, pinning them together, and what is ignored.
Virtualization, containers, storage, backup and deployment.

Placement rules: keeping workloads apart, pinning them together, and what is ignored.

Composing protection across VM, container and distributed storage: what covers what.

Block, file and object storage: what each model addresses, and who owns the metadata.

Sizing with money attached: allocation, lifecycle, and the cost of the reserve.

Knowing how full an environment really is, and taking a host out without an outage.

How a cluster agrees who is alive, what quorum protects, and what its loss costs.

Layers, tags and mounts: what a container image is and where its data actually lives.

When reality diverges from the declaration: detecting, classifying and closing the gap.

Replication, quorum reads and writes, and the trade-offs a distributed pool makes.

Failure domains, consensus and partial failure: why a set of hosts is not a big host.

Three tools and one workload: what Docker, Podman and Compose actually do.

Three backup chains: what each costs to store, what a restore needs, and where they break.

Sharing accelerators: passthrough, vGPU, MIG and MPS, and what inference serving needs.

When a container is unhealthy, what restarts it, and where the logs went.

Restarting workloads after a failure: fencing, timeouts, and how it differs from a backup.

How a hypervisor exposes CPUs, memory and devices to a VM, and what is really emulated.

Declaring infrastructure instead of typing it: idempotence, state, and where it stops.

Why a guest needs its own drivers and tools, and what changes when they are missing.

Moving a running VM: what must be shared, what must be measured, when it stops being live.

Local disks and shared storage seen from the hypervisor: what each gives a workload.

Why the management plane is the highest-value target, and how to keep it apart.

What a set of hosts shares, what it must agree on, and what each host still owns alone.

Two sites, one decision: replication modes, failover, and the difference from backup.

NAS serves files and SAN serves blocks: protocols, who owns the filesystem, and the risks.

Giving a guest a real device: IOMMU groups, isolation limits and what they cost.

Finding the resource that binds: methodology, the tools, and what each counter proves.

Choosing where each workload runs, and what the platform must provide to run both.

Why redundancy keeps a system running and still loses the data — deletion, corruption.

Synchronous and asynchronous replication, and why a replica faithfully copies corruption.

What the hypervisor promises, what it only time-shares, and where overcommit hurts.

Retention, immutability and separate copies: why a deletable copy is not a backup.

Running containers without root: namespaces, capabilities and what isolation misses.

Which mechanism sets the achievable RPO and RTO, and how to read the gap to the objective.

Block and file storage shared between hosts — and the distributed systems replacing a LUN.

Point-in-time copies, copy-on-write chains and consistency: what a snapshot is and is not.

Splitting one NIC into many virtual functions: what it buys and what it gives up.

Templates, linked and full clones, and why a virtual machine snapshot is not a backup.

Where the VMM sits, what virtualizable means, and why the two-type label is a coarse one.

Fixed and dynamic virtual disks, thin pools and overcommit: where the capacity risk sits.

Tagging inside the host: bridges, virtual switches and the VLAN-aware virtual network.

How a virtual machine gets a NIC, and how a host bridge or switch puts it on a network.

Partitions, volumes and filesystems composed into one stack, and where a change is made.

Pools, datasets, copy-on-write snapshots and scrub: detecting and repairing corruption.

How Active Directory stores identity, and how Group Policy outranks local settings.

The first hour on a new Linux server: patch, restrict access, keep visibility.

Default-deny posture, stateful tracking, and how ufw, firewalld or nftables allow SSH.

Partitions, LVM volumes, filesystems: the layers of a local disk and the resize order.

Where a Linux host records what happened — and the messages it never writes at all.

How Linux attaches a filesystem, and why one wrong /etc/fstab line can stall the boot.

How dnf and apt resolve packages, and how to inspect or undo what an update changed.

Two schedulers, one failure mode: cron and systemd timers — and how to prove a job ran.

Host key, user key and session: what SSH establishes, and the settings that harden it.

Units, not processes: what systemd manages, and how systemctl controls a service.

How a process's effective identity, the mode bits and umask decide file access.

Windows DNS and DHCP roles: installing them, configuring zones and scopes, and verifying.

How Windows event logs are read, how services are controlled, and how updates arrive.

What Windows Server roles, role services and features are, and how Server Core differs.

SMB shares and NTFS permissions: how a disk becomes a volume and who can reach it.

Local users and groups, NTFS permissions with icacls, and PowerShell remoting.

Bare metal, hypervisor, host and guest: which layer does what, and what a guest sees.

Firmware initialises the platform, chooses what boots and verifies it — all below the OS.

Cores, hardware threads and vCPUs: three layers, three different numbers.

How a system decides who may touch what: mode bits, umask, ACLs and share rules.

IOPS, throughput and latency: how the medium and the interface decide which one binds.

Two conventions over the same job: configuration, packages, services, support.

Where the real speed of a link is decided: adapter, medium, frame size and host CPU.

The two chains that keep a server up: power in and heat out, and what redundancy covers.

What is running and who says so: processes, services, their supervisor and its log.

What a RAID level buys in availability, capacity and write cost — and where it stops.

Why free memory is not the metric: pages, cache, reclaim and memory pressure.