Introduction to Linux

If you’re getting into DevOps, cloud, or backend engineering, Linux isn’t optional background knowledge — it’s the ground you’re standing on. Your EC2 instances run it. Your Docker containers are built from it. Your Kubernetes nodes are running it under the hood. So let’s actually get comfortable with what it is, instead of just nodding along when someone mentions it.

What Is Linux?

Here’s the honest, slightly nerdy truth: “Linux” technically refers only to the kernel — the core piece of software that talks directly to your computer’s hardware and decides which programs get to use the CPU, memory, and disk at any given moment. A guy named Linus Torvalds wrote the first version of it back in 1991, as a personal project, and released it for free.

What most of us actually mean when we say “I’m running Linux” is really GNU/Linux — the Linux kernel bundled together with a whole toolbox of software from the GNU project (things like bash, coreutils, gcc), plus a package manager to install software, and often a desktop environment on top. That whole bundle is what people package up and call a “distribution” — more on that in a bit.

Think of the kernel as the engine of a car, and a “distribution” as the actual car you drive — same engine underneath, but Ubuntu might feel like a comfortable sedan while Alpine Linux feels like a stripped-down go-kart built for speed.

What Is an Operating System, Actually?

Before Linux makes sense, it helps to be clear on what an operating system even does. An OS is the software layer that sits between your raw hardware (CPU, memory, disk, network card) and every application you run. It’s the thing that:

• Decides which program gets to use the CPU right now, and for how long
• Keeps one program’s memory separate from another’s, so a crash in Chrome doesn’t take down your whole machine
• Manages files and folders on disk
• Lets programs talk to the network, printers, keyboards, and everything else

Without an OS, every app would need to know how to talk to your exact hardware directly — which would be a nightmare. Linux is one operating system’s kernel; Windows and macOS are others.

Linux vs Unix — What’s the Real Relationship?

This one confuses a lot of people, so let’s clear it up simply: Unix came first. It was developed at Bell Labs in the late 1960s and became the foundation for a whole family of operating systems that followed similar design principles — small, composable tools, “everything is a file,” and a strong command-line culture.

Linux was inspired by Unix and built to behave like it, but it isn’t literally a copy of the original Unix source code — Torvalds wrote it from scratch. That’s why you’ll often hear Linux described as “Unix-like.” macOS, interestingly, actually IS certified Unix under the hood (it’s built on Darwin, which descends from BSD Unix), while Linux just follows the same philosophy without sharing the original code.

Linux vs Windows — The Practical Differences

You’ve almost certainly used Windows. Here’s how Linux is genuinely different, beyond just “it looks different”:

• Open source vs. closed source. You can read every line of the Linux kernel’s source code. Windows is proprietary — Microsoft controls it, and you can’t see or modify the internals.
• Free vs. paid. Most Linux distributions cost nothing. Windows licenses cost money, especially for servers.
• Command-line culture. Windows can be run entirely with a mouse. Linux absolutely can too (Ubuntu Desktop, for example), but in server and DevOps contexts, you’re living in the terminal — and that’s actually a feature, not a limitation, because it makes everything scriptable and automatable.
• Everything is a file. On Linux, even hardware devices show up as files you can interact with. Windows has a more separated model with the registry, device drivers, and a very different filesystem structure (C:\ vs. a single / root tree).
• Server market share. Walk into almost any data center or cloud provider, and the servers are running Linux. Windows Server exists and is used, especially in enterprises tied to Microsoft’s ecosystem, but Linux is the default choice for cloud infrastructure, containers, and most modern DevOps tooling.

Neither one is “better” in some abstract sense — they’re built for different priorities. But if your career is heading toward DevOps, cloud, or SRE work, Linux is where you’ll spend almost all your time.

A (Short) History of Linux

You don’t need a history degree here, but the story actually explains a lot about why Linux looks the way it does today:

• 1969 — Unix is born at Bell Labs, setting the philosophical template (small tools, text-based, “everything is a file”).
• 1983 — Richard Stallman launches the GNU Project, aiming to build a completely free Unix-like operating system. By the late 80s, GNU had built almost everything needed — compilers, shells, utilities — except one crucial piece: a working kernel.
• 1991 — A 21-year-old Finnish student, Linus Torvalds, posts to a newsgroup announcing he’s writing “just a hobby” kernel. That kernel becomes Linux, and it slots perfectly into the missing piece of the GNU project.
• 1990s–2000s — Linux gains traction on servers, thanks to being free, stable, and endlessly customizable. Distributions like Debian, Red Hat, and Slackware emerge to package it into something usable.
• 2000s–today — Linux quietly takes over the internet’s backbone: web servers, cloud infrastructure, Android phones (yes, Android runs on the Linux kernel), supercomputers, and now containers and Kubernetes.

The reason this history matters: Linux won not because of marketing, but because it was free, open, and good enough that an entire generation of engineers built the modern internet on top of it.

Linux Distributions

What Is a Linux Distribution?

A “distribution” (or “distro”) is a complete, ready-to-use package built around the Linux kernel. Since the kernel by itself doesn’t do much for you — it needs a shell, package manager, system utilities, and usually a desktop environment or server tooling wrapped around it. Different organizations and communities took the same kernel and assembled it differently, aimed at different goals: some for servers, some for beginners, some for security research, some for tiny embedded devices.

That’s why you’ll hear “which distro do you use?” as a genuinely meaningful question — the kernel is shared, but the day-to-day experience (package manager, default configuration, release schedule, support model) can be really different.

Popular Distributions You’ll Actually Run Into

Ubuntu

Debian

RHEL

Rocky Linux

AlmaLinux

Amazon Linux

Ubuntu — Probably the most beginner-friendly, widely-used distro out there. Built by Canonical, based on Debian, and hugely popular for both desktops and cloud servers (it’s one of the default AMI choices on AWS). Uses apt for package management.

Debian — The distribution Ubuntu itself is built on. Known for being extremely stable and conservative about what changes go in — Debian would rather ship something a bit older and rock-solid than something new and shaky. A favorite for production servers where uptime matters more than having the newest software.

RHEL (Red Hat Enterprise Linux) — The enterprise standard. Companies pay Red Hat for RHEL because they want a supported, certified, battle-tested OS with a support contract behind it — critical for regulated industries (banking, healthcare, government). Uses dnf/yum and the .rpm package format.

Rocky Linux — Born after CentOS (which used to be the free, community version of RHEL) changed its model in 2020 and stopped being a stable long-term option. Rocky Linux stepped in as a free, community-driven, binary-compatible rebuild of RHEL — basically “RHEL, without the subscription fee.” Very popular for anyone who wants RHEL-like stability without the enterprise price tag.

AlmaLinux — Created around the same time and for the same reason as Rocky Linux, by the CloudLinux team. Also a free, RHEL-compatible rebuild. Rocky and AlmaLinux are essentially siblings solving the same problem, and picking between them often comes down to community/vendor preference rather than a technical difference.

Amazon Linux — AWS’s own distribution, built by Amazon and optimized specifically to run well on EC2. It’s RHEL/Fedora-flavored under the hood (uses dnf), tuned for AWS integration, and it’s usually the default, “just works” choice if you’re spinning up an EC2 instance and don’t have a strong opinion otherwise.

What Do People Actually Use Linux For?

• Web and application servers — the vast majority of websites and backend services run on Linux servers.
• Cloud infrastructure — AWS, GCP, and Azure all run their infrastructure predominantly on Linux, and most VM images offered to customers are Linux-based.
• Containers — Docker images are built from Linux distributions (or minimal Linux environments like Alpine); container technology fundamentally depends on Linux kernel features.
• Embedded and IoT devices — routers, smart TVs, and countless embedded devices run stripped-down Linux.
• Supercomputers — essentially all of the world’s fastest supercomputers run Linux.
• Mobile — Android is built on top of the Linux kernel.
• Developer workstations — many software engineers, especially in backend/DevOps roles, use Linux (or macOS, which behaves similarly) as their daily driver because the tooling lines up so closely with what production servers run.

Why Do People Actually Prefer Linux? (The Real Advantages)

• It’s free. No licensing costs, which matters enormously at cloud scale where you might be running thousands of servers.
• It’s open source. You (or your company) can inspect, audit, and modify the source code — a big deal for security-conscious organizations.
• It’s stable. Linux servers routinely run for months or years without needing a reboot.
• It’s scriptable and automatable. Nearly everything can be controlled from the command line, which is exactly what tools like Ansible, Terraform, and CI/CD pipelines depend on.
• It’s lightweight. You can run a fully functional Linux system with a tiny memory and disk footprint — essential for containers, where image size directly affects deploy speed and cost.
• It has a massive community. Whatever problem you’re hitting, someone has almost certainly hit it before and written about the fix.

Why Linux Is the Backbone of DevOps

The DevOps Connection

Here’s the thing that ties this whole article together: DevOps as a discipline is built almost entirely on top of Linux. The tools that define modern DevOps — Docker, Kubernetes, Terraform, Ansible, Jenkins, CI/CD runners — are either Linux-native or run best on Linux. If you want to genuinely understand why those tools behave the way they do, you need to understand the Linux concepts underneath them (processes, permissions, networking, the filesystem) — which is exactly what the rest of this Fundamentals series covers.

Linux in AWS

Most EC2 instances run Linux. Amazon even built its own distribution (Amazon Linux) specifically tuned for it. Nearly every AWS service you’ll interact with as a DevOps engineer — from the CLI tools you install, to the Lambda runtime environments, to the EKS worker nodes — is Linux underneath.

Linux in Docker

Docker isn’t magic — it’s a clever use of Linux kernel features called namespaces (which isolate what a process can see) and cgroups (which limit what resources a process can use). A Docker container doesn’t run a separate operating system; it’s a regular Linux process, isolated to look and feel like its own little machine. That’s exactly why containers start in milliseconds instead of the minutes a full virtual machine takes.

Linux in Kubernetes

Every Kubernetes node is a Linux machine (or increasingly, in mixed clusters, Windows nodes for specific workloads — but the vast majority is Linux). When Kubernetes schedules a pod, sets CPU/memory limits, or handles a graceful shutdown, it’s ultimately manipulating the exact same Linux primitives — cgroups, signals, namespaces — that you’ll learn about in this series. Understanding Linux is what lets you actually debug Kubernetes instead of just guessing.

Linux in CI/CD

Nearly every CI/CD runner — GitHub Actions, GitLab CI, Jenkins agents — spins up a Linux environment to actually execute your build and test steps. Your pipeline YAML is really just a structured way of running a sequence of Linux shell commands.

Linux in Cloud Environments

Zoom out, and the pattern is the same across every major cloud provider: the majority of virtual machines, managed services, and container platforms are built on Linux. Cloud computing as an industry grew up hand-in-hand with Linux, precisely because it’s free, stable, and automatable at massive scale — you can’t cost-effectively run millions of servers on a per-license operating system.

Quick Interview Answer

“Linux is a free, open-source, Unix-like kernel originally created by Linus Torvalds in 1991. A ‘Linux distribution’ pairs that kernel with tools from the GNU project and a package manager into something usable — Ubuntu and Debian are Debian-based, while RHEL, Rocky Linux, AlmaLinux, and Amazon Linux are all RHEL-family. It matters for DevOps because Docker, Kubernetes, and most cloud infrastructure are built directly on Linux kernel features like namespaces and cgroups, not just deployed on top of Linux incidentally.”

Common Mistakes

• Saying “Linux” when you actually mean one specific distro’s behavior — a lot of “quirks” people blame on Linux are really just a particular distro’s default configuration.
• Assuming Linux and Unix are the same thing — Linux is Unix-like, inspired by and philosophically similar to Unix, but not built from the original Unix source code.
• Thinking Rocky Linux and AlmaLinux are competing with RHEL — they’re specifically designed to be compatible rebuilds of RHEL, filling the gap CentOS left behind.
• Assuming all distros share the same package manager or file layout — always check /etc/os-release on an unfamiliar system before assuming.