Unit 13 · Cloud research · Lesson 5 of 5
Cloud paper route: Firecracker and cluster management
Step 1: Learn the ideas
- Isolation options: Linux containers, language-VM isolation, hardware virtualization
- Firecracker VMM: KVM, virtio devices, REST API, rate limiters, jailer
- Firecracker in Lambda: slots, MicroManager, placement, soft allocation and oversubscription
- Firecracker evaluation: boot time, memory overhead, I/O; production migration
- Borg: cells, jobs, allocs, priorities, quota, scheduling, reclamation, isolation
- Cell compaction as an evaluation method
- Serverless in the Wild: characterization and hybrid histogram policy
- Related systems at awareness level: gVisor, Kata Containers, unikernels, Kubernetes, Omega
Why it matters
Research interviews in cloud computing expect you to discuss papers the way authors and reviewers do: what problem, which mechanism, what evidence, what is argued versus measured, and what remains open. This route anchors on Firecracker, which is short, concrete and full of explicit trade-offs, and places it beside cluster management (Borg) and a production workload study (Serverless in the Wild), so that isolation, scheduling and elasticity connect.
Core ideas
Reading order.
- Firecracker (NSDI 2020): why AWS Lambda needed VM-grade isolation with container-like density and startup, how a minimal KVM-based VMM provides it, and how Lambda uses it.
- Borg (EuroSys 2015): how a large cluster manager admits, places, preempts and isolates work, and how it evaluates packing policies.
- Serverless in the Wild (USENIX ATC 2020): what a production FaaS workload looks like and how a per-application policy trades cold starts against memory.
Optional context: DRF for multi-resource fairness, Heracles for interference-aware co-location, and the OSTEP appendix on virtual machine monitors as background for Firecracker.
What to extract from Firecracker. The six requirements the authors set (isolation, overhead and density, performance, compatibility, fast switching, soft allocation); why containers force a choice between syscall filtering and compatibility, and why language-level isolation could not run arbitrary binaries; the design choices (KVM, a small Rust VMM, a minimal virtio device set, block devices instead of filesystem passthrough, a REST API, token-bucket rate limiters, one VMM process per microVM inside a jailer); how Lambda uses microVMs as slots with a pool of pre-booted VMs; and the argument that oversubscription is a statistical bet that holds only for uncorrelated workloads.
Argued versus measured. Isolation is argued qualitatively: a smaller trusted computing base, a hardware virtualization boundary, defense in depth, and deployment guidance on side channels. Boot time, memory overhead and I/O are measured on one bare-metal host against QEMU and Cloud Hypervisor. Statements about Lambda in production are reported experience, not controlled experiments. Keep the three kinds of claims apart in your notes.
Connections. Firecracker relies on Linux for scheduling and memory management, so noisy-neighbor problems move rather than disappear (interference topic). Borg's reclamation and overcommit are the cluster-level counterpart of Firecracker's soft allocation (scheduling topic). Serverless in the Wild explains why fast switching matters economically (elasticity topic).
Common misconceptions
- "Firecracker shows VMs beat containers in general." It argues for one set of constraints (untrusted multi-tenant code, arbitrary Linux binaries, high density) and accepts trade-offs: a limited device model, no VM migration, and block I/O below QEMU in its own evaluation.
- "The evaluation measures isolation." It measures boot time, memory overhead and I/O; isolation rests on design arguments.
- "Borg's utilization gains transfer to any cluster." They depend on Google's mix of production and batch work, its constraints and reclamation, and were measured by compaction in simulation from production checkpoints.
- "Serverless in the Wild recommends a longer keep-alive." It shows that one fixed window fits a skewed workload badly and that adapting per application improves the trade-off.
- "The abstract and evaluation are enough." Assumptions in the design sections (Linux guests, small functions, the threat model) bound every claim.
How to approach it
Read each paper in three passes with its paper guide, fill in the structured notes, and prepare a two-minute and a ten-minute explanation of Firecracker. For each paper, write one follow-up experiment you could actually run, such as measuring microVM boot-time distributions on your own host or replaying the Functions trace against another keep-alive policy.
Suggested order
- 1Read the OSTEP appendix on virtual machine monitors to refresh how a hypervisor multiplexes operating systems.
- 2Read Firecracker in three passes with its paper guide and fill in the structured notes.
- 3Skim the Firecracker repository design document to see how the design has evolved since the paper.
- 4Read Borg in three passes with its paper guide, focusing on scheduling, reclamation and the compaction methodology.
- 5Read Serverless in the Wild with its paper guide, then try the keep-alive simulation project.
- 6Prepare a two-minute and a ten-minute explanation of Firecracker and present both out loud.
Paper guides: Firecracker: Lightweight Virtualization for Serverless Applications, Large-scale cluster management at Google with Borg, Serverless in the Wild: Characterizing and Optimizing the Serverless Workload at a Large Cloud Provider
Step 2: Check off what you can do
Tap each one you can genuinely do or explain. Each earns 10 XP.
Step 3: Go deeper
Firecracker: Lightweight Virtualization for Serverless ApplicationsStart here
USENIXThe anchor paper: isolation options, VMM design, Lambda integration and evaluation.
Open(opens in a new tab)Link responded, 5 Oct 2026Large-scale cluster management at Google with BorgStart here
Google ResearchCluster management design and the cell-compaction evaluation method.
Open(opens in a new tab)Link responded, 5 Oct 2026Serverless in the Wild: Characterizing and Optimizing the Serverless Workload at a Large Cloud Provider
USENIXProduction workload characterization and a trace-driven policy evaluation.
Open(opens in a new tab)Link responded, 5 Oct 2026Firecracker repository documentation
Firecracker project (GitHub)Section: Design document
The current design and threat containment, to compare with the paper’s description.
Open(opens in a new tab)Link responded, 5 Oct 2026Operating Systems: Three Easy Pieces
University of Wisconsin–Madison (free online book)Section: Appendix B: Virtual Machine Monitors
Background on how a VMM virtualizes CPU and memory before reading Firecracker.
Open(opens in a new tab)Link responded, 5 Oct 2026
Step 4: Practice
Treat each paper as a set of claims to check. For Firecracker, boot microVMs on a KVM-capable Linux host and measure a startup distribution with a method written down before running, then compare your definition of boot time with the paper’s. For Serverless in the Wild, replay a sample of the Functions trace against fixed and adaptive keep-alive policies. Keep structured notes per paper in the app; reading without notes does not complete the route.
- Boot Firecracker microVMs and measure startup yourselfOpen(opens in a new tab)Not attemptedSelf-directed (Firecracker)
- Simulate serverless keep-alive policies on the Azure Functions traceOpen(opens in a new tab)Not attemptedSelf-directed (Azure Public Dataset)
Record attempts on each problem’s page (+15 XP, +10 more when solved on your own).
Step 5: Test yourself
Answer each one out loud or on paper before you finish the lesson.
- Question 1Which of Firecracker’s six requirements are quantitative, and which are argued?
- Question 2Why did the authors choose block devices over filesystem passthrough?
- Question 3What role does the jailer play if the VMM itself is compromised?
- Question 4How does Borg’s resource reclamation relate to Firecracker’s soft allocation?
- Question 5What do cold-start percentage and wasted memory time measure in Serverless in the Wild?
You’re done when you can
- Complete structured notes for all three papers, separating design arguments from measured results.
- Give a two-minute and a ten-minute explanation of Firecracker, including its limitations.
- Explain how Borg evaluates packing policies and one threat to the validity of that method.
- Propose one follow-up experiment per paper that you could run with available resources.


