There is a certain temptation when learning Linux to immediately build a gigantic home lab with:
- Fancy hardware (you know, the blinking colorful keyboard and 5 screens)
- 15 virtual machines
- VLANs everywhere
- Kubernetes
- enterprise routing
- dashboards that look like NASA telemetry
(Ok, maybe I’m exaggerating quite a bit)
And then three days later you realize you can no longer remember which VM broke DNS.
So I decided to start smaller.
Way effing smaller.
Instead of building a fake Fortune 500 data center in my laptop, I built a focused Linux engineering lab using only three Ubuntu virtual machines.
(Yes, I’m running everything on a laptop sporting an i5 processor with 32 GB of RAM and 512 GB of SSD. I can’t use the gaming machine on this, yet. I still need a native Windows machine to run ESRI software for class. Hey, when I do school stuff, a compromise with Windows is better than messing with a VM running ArcGIS Pro)
And honestly, this is probably the better way to learn.
Why I Chose virt-manager Instead of VirtualBox
I decided to use:
instead of VirtualBox.
Not because it sounds cooler on Linux forums, but because it is simply the better long-term platform for learning Linux infrastructure engineering.
virt-manager uses:
- KVM (Kernel-based Virtual Machine)
- libvirt
- native Linux virtualization technologies
Which means I am learning virtualization technologies that are actually used in real Linux infrastructure environments.
This matters.
A lot.
VirtualBox is fine for quick testing and beginner experimentation. But if the goal is eventually becoming strong in:
- Linux administration
- networking
- infrastructure engineering
- systems engineering
then learning KVM/libvirt early makes far more sense.
(Plus it runs faster on my setup than VirtualBox)
Why virt-manager Makes Sense for Linux Learning
Using virt-manager also teaches:
- virtual networking
- bridges
- NAT networking
- snapshots
- storage pools
- Linux virtualization concepts
- VM lifecycle management
without requiring a full enterprise hypervisor stack.
And unlike some enterprise virtualization platforms, virt-manager feels lightweight and approachable enough for a personal lab.
It also integrates naturally into Linux itself instead of feeling like a separate application awkwardly bolted onto the operating system.
Linux is hosting Linux using Linux-native virtualization.
There is something beautifully nerdy about that.
(Yes, this includes fixing the quirkiness of Virt with ports)
The Goal
The purpose of this lab is not to impress people on Reddit with screenshots of blinking dashboards.
The goal is to actually understand:
- Linux
- networking
- Bash scripting
- systems programming in C
- client/server communication
- infrastructure troubleshooting
This lab is designed for learning Linux as an engineering platform, not just as a desktop operating system.
(Meet your future haxxor)
The 3-VM Design
The lab currently consists of:
| VM Name | Purpose |
|---|---|
| ubuntu-admin01 | Main administration and scripting server |
| ubuntu-dev01 | C programming and systems programming environment |
| ubuntu-client01 | Testing client for networking and services |
That is it.
No Kubernetes.
No “cloud-native AI blockchain observability platform.”
No unnecessary complexity.
Just Linux.
Network Design
The VMs are connected using a private internal NAT network.
They can:
- communicate with each other
- access the Internet
- remain isolated from the host machine and the rest of the home network
Network:
192.168.100.0/24IP assignments:
| VM | IP Address |
|---|---|
| ubuntu-admin01 | 192.168.100.10 |
| ubuntu-dev01 | 192.168.100.20 |
| ubuntu-client01 | 192.168.100.30 |
This setup keeps the lab:
- simple
- safe
- isolated
- easy to troubleshoot
Which is exactly what a beginner lab should be.
Recommended Specs
ubuntu-admin01
| Resource | Recommended |
|---|---|
| RAM | 4 GB |
| vCPU | 2 |
| Disk | 40–60 GB |
Use for:
- Linux administration
- Bash scripting
- networking tools
- firewall basics
- SSH
- package management
This becomes your:
main Linux learning environment.
ubuntu-dev01
| Resource | Recommended |
|---|---|
| RAM | 4 GB |
| vCPU | 2 |
| Disk | 30–40 GB |
Install:
- gcc
- make
- gdb
- valgrind
- git
Use for:
- C programming
- socket programming
- testing code
- debugging
This separation is good because:
you’ll break things while learning C.
ubuntu-client01
| Resource | Recommended |
|---|---|
| RAM | 2 GB |
| vCPU | 1 |
| Disk | 20 GB |
Use for:
- SSH testing
- ping tests
- client/server apps
- DNS testing
- firewall testing
This VM teaches:
infrastructure interaction.
Very important.
Why Separate the Development VM?
Because I fully expect to break things.
A lot.
The development VM is where:
- C programs get compiled
- sockets get tested
- processes crash
- memory leaks happen
- experiments go sideways
Keeping it separate from the main administration VM creates cleaner operational discipline.
Even in a small lab, separation of responsibilities matters.
Why Only 3 VMs?
Because deep understanding matters more than lab size.
A beginner who deeply understands:
- networking between 3 systems
- SSH
- services
- packet flow
- Bash scripting
- sockets
- Linux internals
is already ahead of many people who simply copy tutorials into massive labs they barely understand.
Yes. I am looking at you tech bloggers who have those fancy keyboards, some effing ginormous amount of screen space, and don’t really do anything but run:
sudo apt update && sudo apt full-upgrade -y && sudo apt autoremove -y && sudo apt cleanThis lab is intentionally small so I can:
- focus on Linux fundamentals
- understand every component
- troubleshoot issues myself
- document everything properly
What I’m Learning in This Lab
Using only these 3 VMs, I can already learn:
- Linux administration
- static IP configuration
- SSH
- firewall basics
- Bash scripting
- packet captures
- TCP/IP networking
- socket programming in C
- process management
- logging
- monitoring
That is already a massive amount of engineering knowledge.
Why Linux + C Programming Together?
Because Linux makes more sense when you understand what is happening underneath.
Writing C programs on Linux teaches:
- processes
- files
- sockets
- memory
- system calls
- networking internals
You stop seeing Linux as:
“a collection of commands”
and start seeing it as:
an operating system engineering environment.
That changes everything.
Future Expansion
Eventually this lab will grow into:
- DNS infrastructure
- DHCP services
- Linux firewall/router
- centralized logging
- monitoring systems
- automation frameworks
- network services
But not yet.
Right now the goal is:
- understanding
- repetition
- troubleshooting
- engineering fundamentals
Not pretending to run a fake hyperscale cloud provider from the living room.
(Plus I don’t really have the money to spend on hardware, I buy refurbished)
Final Thoughts
There is something refreshing about starting small and actually learning deeply.
Three Ubuntu Server VMs.
One subnet.
SSH.
Bash.
C programming.
Networking.
Simple.
But underneath that simplicity is the foundation of:
- Linux engineering
- infrastructure operations
- network engineering
- systems programming
- cybersecurity
And honestly, that feels far more valuable than chasing buzzwords.
(And honestly, combining Linux and C programming feels a bit like carrying a double-bladed lightsaber, powerful, dangerous, occasionally frustrating, and absolutely capable of cutting through shallow understanding. Hopefully without losing a limb in the process.)