From Virtualization to Linux: Building the Foundation for DevOps

In the last post, we explored virtualization. How hypervisors and virtual machines allow us to run multiple operating systems on a single physical machine. But spinning up a VM is just the first step.

Once your VM is live, the real work begins. And more often than not, that work happens on Linux.

Linux isn’t just an operating system; it’s the backbone of DevOps. Whether you’re deploying a Kubernetes cluster, setting up CI/CD pipelines, or managing servers in AWS, Linux commands, tools, and principles are the foundation you’ll rely on daily.

Why Linux Matters for DevOps

If virtualization gives you the house, Linux is the floor you walk on, the walls you touch, and the wiring that powers everything.

Here’s why:

• Most servers run Linux: From AWS EC2 to supercomputers.
• Automation loves Linux: Scripting, configuration management, and containerization are easier in Linux environments.
• Flexibility & security: Open source means constant improvement, customization, and wide hardware support.

Linux isn’t optional for DevOps; it’s the language of the trade.

What is Linux?

At its core, Linux is an open-source operating system kernel. Linus Torvalds created it in 1991, and when combined with GNU tools, it became the operating system we use today.

From Ubuntu and CentOS to Android, Linux has grown into countless distributions (“distros”) that power everything from your phone to massive cloud data centers.

The Four Pillars of Linux for DevOps

To be effective in DevOps, you don’t need to be a hardcore system administrator, but you do need to master the fundamentals. Think of them as four pillars:

1. Commands: Navigation, file manipulation, user management.
2. Files: Understanding the filesystem, permissions, configuration.
3. Software: Package managers (yum, apt, rpm, dpkg), installing dependencies.
4. Servers: Managing services and processes, setting up web & database servers.

Open Source: More Than “Free Software”

When people hear “open source,” they often think “free.” But it’s more than that.

Open source means the code is open for inspection, modification, and redistribution. Thousands of contributors worldwide can improve it, making it more secure and innovative than proprietary software maintained by a small, closed team.

That’s why open source is the lifeblood of DevOps: collaboration, transparency, and rapid improvement.

Key Linux Principles for DevOps

Linux was built with philosophies that map directly into DevOps practices:

• Everything is a file: Even devices like keyboards and disks.
• Small single-purpose programs: Combine them like CI/CD steps.
• Avoid captive UIs: Automation > manual clicks.
• Configuration in text files: Perfect for automation and version control.

Linux Architecture at a Glance

Think of Linux in layers:

• Hardware: CPU, RAM, storage.
• Kernel: Controls and allocates hardware resources.
• Shell: Your gateway to commands.
• Tools: Commands, scripts, and applications.

Every command you type eventually talks to the kernel, which manages the hardware.

Distributions You’ll Meet

As a DevOps engineer, you’ll encounter two main Linux families:

• RPM-based: Red Hat, CentOS, Fedora, openSUSE, Amazon Linux.
• Debian-based: Ubuntu, Debian, Kali, and variants.

Both families differ mainly in package management (RPM .rpm vs Debian .deb). For example:

# Debian-based
dpkg -i google-chrome.deb  

# RPM-based
rpm -ivh google-chrome.rpm  
        

Pro tip: DevOps engineers should be comfortable in both worlds.

Exploring the Linux Filesystem

Some key directories you’ll work with:

• /home: user home directories.
• /etc: configuration files.
• /var: logs, web data, databases.
• /boot: kernel & boot loader.
• /bin & /sbin: executables (normal & root).
• /proc & /sys: system information.

Mastering where things live is crucial for debugging and automation.

Getting Hands-On: First Commands

Once your VM is running (from the virtualization lesson), log in and try:

whoami       # current user  
pwd          # current directory  
ls           # list files  
cat /etc/os-release  # OS info  
        

Switch to root with:

sudo -i  
        

Congratulations—you’re now operating as the system administrator of your own VM.

Moving Forward

Linux is not just another skill, it’s the core skill. Every DevOps tool you’ll learn later, from Docker, Kubernetes, Terraform, CI/CD assumes you can navigate Linux comfortably.

In this blog, we touched on:

• Why Linux matters in DevOps.
• The philosophy and principles behind Linux.
• How distributions and package management differ.
• The Linux filesystem and basic commands.

In the next article, we’ll dive deeper into hands-on Linux commands and scripting, so you can move from theory to practical DevOps workflows.

If you’ve just finished the virtualization setup, now’s the perfect time to practice Linux. Try spinning up a VM, logging in, and running the commands above. Then follow along in the next post, where we’ll level up with automation.