Linux is the operating system the internet runs on. The web server that answered this page, the containers in a Kubernetes cluster, the runner that executes a CI pipeline and the router in your living room are, almost certainly, Linux. If you work in DevOps you do not get to avoid it, so the good news first: Linux is not hard. It is consistent. Once you understand a handful of ideas, everything else is the same ideas applied again.
In this lesson you learn what the word “Linux” really refers to, why it took over servers, which flavours you will meet at work, and you set up a lab machine where you can break things safely.
What “Linux” means
Strictly speaking, Linux is a kernel: the program that starts first when the machine boots and stays in charge until it shuts down. Linus Torvalds wrote the first version in 1991 as a hobby, published the source code, and thousands of people and companies have improved it since.
The kernel is the referee between programs and hardware. Programs never touch the disk, the network card or memory directly; they ask the kernel. Its main jobs:
- Processes: start programs, give each one a turn on the CPU, stop them.
- Memory: hand out RAM, keep programs from reading each other’s memory.
- Devices: talk to disks, network cards and USB through drivers.
- Files: organise data on disks into files and directories.
- Security: decide which user may read which file or open which port.
On its own, a kernel is not much use: you cannot log in to it or type commands into it. What people usually mean by “Linux” is a complete system built around that kernel.
Kernel, distribution and shell
Three words cover nearly every conversation about Linux. Think of a restaurant:
| Piece | What it does | Restaurant | Examples |
|---|---|---|---|
| Kernel | Manages hardware, memory, processes and files | The kitchen: nobody sees it, nothing works without it | Linux 6.x / 7.x |
| Distribution | Bundles the kernel with tools, libraries, a package manager and a release schedule | The whole restaurant: menu, staff, opening hours | Ubuntu, Debian, RHEL, Rocky, Alpine |
| Shell | Reads the commands you type and starts programs | The waiter who takes your order to the kitchen | bash, zsh, sh, fish |
When a colleague says “the server runs Linux”, they mean a distribution. When they say “run this in Linux”, they mean “type it into a shell“. When a security advisory says “Linux is vulnerable”, it means the kernel, and the fix arrives as a distribution update.
Terminal versus shell
People use the two words interchangeably, but they are different programs. The terminal is the window that shows text and sends your keystrokes: Windows Terminal, the macOS Terminal app, GNOME Terminal. The shell runs inside it and interprets what you type. You can run bash in any terminal, and any terminal can run zsh.
Why Linux runs the backend of the world
Linux is not on servers by accident. It fits the job:
- It is free to run anywhere. No licence per server, per core or per container. Starting a thousand short-lived CI runners costs nothing extra.
- It is scriptable all the way down. Everything you can do by hand you can do in a script, and every setting lives in a text file you can version in Git.
- It is transparent. Logs are text, configuration is text, and the system exposes its own state as files under
/procand/sys. You can always find out why. - It is small when it needs to be. A minimal container image is a few megabytes; the same kernel runs a supercomputer.
- It stays up. Servers run for months between reboots, and even kernel security fixes can often be applied live.
- Every tool supports it first. Docker, Kubernetes, Terraform, Prometheus, Ansible and every cloud CLI treat Linux as home.
Containers are a Linux feature
A container is not a small virtual machine. It is an ordinary Linux process that the kernel fences off with two features:
- Namespaces give the process its own view of the world: its own process list, network interfaces, hostname and filesystem.
- cgroups (control groups) cap what it can use: CPU, memory, disk I/O.
That is why Docker Desktop on Windows and macOS quietly runs a small Linux virtual machine: containers need a Linux kernel. Understanding Linux is understanding what your containers really are.
The distributions you will meet
There are hundreds of distributions, but servers and containers in 2026 mostly use four families:
| Family | Distributions | Package manager | Where you meet it |
|---|---|---|---|
| Debian | Ubuntu, Debian | apt (.deb packages) | Cloud VMs, CI runners, most tutorials. Ubuntu 26.04 LTS is supported until 2031 |
| Red Hat | RHEL, Rocky Linux, AlmaLinux, CentOS Stream, Fedora | dnf (.rpm packages) | Banks, telecoms, enterprises with support contracts. RHEL 10 is the current major release |
| Alpine | Alpine Linux | apk | Container images: the base image is about 8 MB |
| Others | SUSE, Arch, Amazon Linux, Flatcar, Bottlerocket | zypper, pacman, dnf | Specific clouds, enthusiasts, container-only hosts |
Two details that save confusion later:
- CentOS Linux is gone. Its last release reached end of life in 2024. The old free clone of RHEL lives on as Rocky Linux and AlmaLinux; CentOS Stream is now the preview of the next RHEL, not a clone of the current one.
- Alpine uses musl, not glibc. Most distributions share the GNU C library; Alpine uses a smaller one called musl. Programs compiled elsewhere sometimes fail on Alpine with confusing “file not found” errors, which is why some teams prefer
debian-slimor distroless images.
LTS releases
Servers want stability, so they run long-term support releases: versions that receive security fixes for years without changing behaviour. Ubuntu publishes an LTS every two years (24.04, 26.04), each with five years of standard updates. RHEL majors are supported for ten years. Short-lived releases such as Ubuntu 25.10 or Fedora are great for trying new things and poor choices for production.
Same idea, different words
Installing the nginx web server shows how similar the families are:
# Ubuntu and Debian
$ sudo apt update
$ sudo apt install nginx
# RHEL, Rocky, Alma, Fedora
$ sudo dnf install nginx
# Alpine
$ sudo apk add nginx
The command changes, the idea does not. Lesson 13 covers package management properly.
Where Linux runs
The same kernel turns up in very different places, and you will touch all of them:
- Physical servers in a data centre, managed over the network.
- Virtual machines in a cloud: an EC2 instance, an Azure VM, a Google Compute Engine VM.
- Containers that share the kernel of their host, built from images like
ubuntu,debianoralpine. - Managed services that hide Linux but run on it: serverless functions, managed Kubernetes nodes, CI runners.
- Devices: routers, TVs, cars, Android phones.
A typical week for Orbit’s team touches four of them: the API runs in containers on Kubernetes nodes running Ubuntu, the CI pipeline runs on Linux runners, the build images are based on Debian, and the old reporting server is a Rocky Linux VM nobody wants to migrate.
Why the command line
Linux has excellent desktops, and they are a fine way to learn. Servers, however, almost never have a screen. You reach them over SSH (lesson 16), a remote shell, so the command line is the only interface you get.
That turns out to be an advantage:
- It scales. Clicking through a settings window on one server is fine. On forty servers, a command in a loop or a script is the only sane way.
- It is repeatable. A command can go into a script, a runbook or a pipeline, and runs the same way next time.
- It is reviewable. A colleague can read your command in a merge request. Nobody can review a sequence of clicks.
- It is fast. Over a slow connection, text beats a remote desktop every time.
Open source and why it matters to you
The kernel and most of a distribution are open source: anyone may read, change and redistribute the code under licences such as the GPL. For a DevOps engineer that is not ideology, it is practical:
- When something misbehaves, you can read exactly what the code does instead of guessing.
- You can choose the distribution that fits a workload, or build a minimal one for containers.
- No single vendor can lock you in, raise prices or end support for your platform overnight.
- Security fixes are public and reviewed by many eyes, and you can see exactly what changed.
Set up your lab machine
Every lesson in this course has commands to try. You need a Linux machine where mistakes do not matter. Pick one option; the first is the most complete.
Option 1: an Ubuntu VM with Multipass (recommended)
Multipass, made by Canonical, starts Ubuntu virtual machines with one command on Windows, macOS and Linux. Install it from the Multipass website, then:
$ multipass launch 26.04 --name orbit-lab --cpus 2 --memory 2G --disk 10G
Launched: orbit-lab
$ multipass shell orbit-lab
ubuntu@orbit-lab:~$
The prompt tells you three things: you are user ubuntu, on the host orbit-lab, in your home directory (~). Leave with exit; stop the VM with multipass stop orbit-lab and remove it with multipass delete --purge orbit-lab when you are done with the course.
Option 2: WSL on Windows
The Windows Subsystem for Linux runs a real Linux kernel next to Windows. In PowerShell, list the distributions and install the newest Ubuntu:
PS> wsl --list --online
PS> wsl --install -d Ubuntu-26.04
WSL is excellent for daily work. Recent versions run systemd by default, so almost every lesson works; the firewall lessons are the exception and are easier on a Multipass VM.
Option 3: a container, for the first lessons
If you already have Docker, a throwaway container is enough for the lessons on files, text, permissions, users and scripting:
$ docker run -it --rm --name orbit-lab --hostname orbit-lab ubuntu:26.04 bash
root@orbit-lab:/#
Everything disappears when you exit, which is perfect for experiments. Containers do not run systemd, so lessons 9, 15 and 17 need one of the first two options.
Your first commands
Open a shell on your lab machine and ask it some questions:
$ whoami
ubuntu
$ hostname
orbit-lab
$ uname -r
7.0.0-15-generic
$ cat /etc/os-release
PRETTY_NAME="Ubuntu 26.04 LTS"
NAME="Ubuntu"
VERSION_ID="26.04"
ID=ubuntu
ID_LIKE=debian
...
whoamiprints the user you are logged in as.hostnameprints the machine’s name.uname -rprints the kernel version. Your number will differ; that is fine./etc/os-releasedescribes the distribution. It exists on every modern distribution, so scripts read it to find out where they are running.ID_LIKE=debiantells you which family Ubuntu belongs to.
Now find out which shell you are using and how long the machine has been up:
$ echo $SHELL
/bin/bash
$ uptime
09:41:07 up 12 min, 1 user, load average: 0.02, 0.05, 0.01
Three questions, three layers: the kernel (uname), the distribution (/etc/os-release) and the shell ($SHELL). These are the first commands experienced engineers type on a server they have never seen before.
Tip: Ubuntu 25.10 and 26.04 ship Rust rewrites of core tools: uutils coreutils (ls, cp, cat and friends) and sudo-rs. They are designed as drop-in replacements, so every command in this course behaves the same. You will only notice if you read the version strings.
Practice lab
Your manager asks for a quick inventory of the new lab machine before the team starts using it. Collect these facts using only the shell:
- The kernel version and the distribution name, version and family.
- The number of CPU cores and the total and available memory.
- The shell you are using and how long the machine has been running.
- Bonus: start a throwaway
alpinecontainer (if you have Docker) and run the samecat /etc/os-release. Compare theIDand the size of the image withdocker images.
Show a solution
uname -r prints the kernel, and cat /etc/os-release prints the distribution (PRETTY_NAME, VERSION_ID) and its family (ID_LIKE=debian). nproc counts CPU cores and free -h shows total and available memory in readable units. echo $SHELL names your shell and uptime shows how long the machine has been up. For the bonus, docker run --rm alpine cat /etc/os-release prints ID=alpine, and docker images shows the Alpine image at a few megabytes against roughly 80 MB for Ubuntu.
Myths worth dropping now
- “Linux is only for experts.” You need about thirty commands for daily work, and this course teaches them in context.
- “Linux and Unix are the same thing.” Linux behaves like Unix and follows the same conventions, but it is an independent implementation. macOS is a certified Unix; Linux is not, and the differences show up in small flags.
- “You have to pick the perfect distribution.” The skills transfer. Learn Ubuntu, recognise the RHEL family, know that Alpine is different.
- “The GUI is the real system and the terminal is for hackers.” On a server the terminal is the system.
Exercise
A security bulletin says “a Linux vulnerability allows local users to gain root”. Which layer is affected, and how does the fix normally reach your Ubuntu server?
Show answer
Answer: B. “Linux” in a vulnerability report usually means the kernel. The distribution packages the fixed kernel, and you apply it with the package manager (and a reboot or live patch).
Exercise
The Orbit team needs the smallest possible base image for a container. Which distribution is the usual choice, and what is the catch?
Show answer
Answer: C. Alpine images are only a few megabytes. Its C library is musl, so software built against glibc may fail. CentOS Linux reached end of life in 2024.
Exercise
You log in to an unfamiliar server. Which command tells you the distribution and its version?
Show answer
Answer: C. /etc/os-release describes the distribution. uname -r shows the kernel version, $SHELL your shell and whoami your user name.
Key takeaways
- Linux is a kernel; a distribution wraps it into a complete operating system; the shell is how you talk to it.
- Servers, containers and CI runners use Linux because it is free, scriptable, transparent, small and supported by every tool.
- Containers are Linux processes isolated with namespaces and limited with cgroups.
- Know the families: Debian/Ubuntu (
apt), Red Hat (dnf), Alpine (apk). Run LTS releases in production. - Servers are managed from the command line over SSH, and that is what makes automation possible.
FAQ
Which distribution should I learn first for DevOps?
Ubuntu LTS. It is the default on most clouds and CI runners, and most documentation uses it. Once you are comfortable, spend an afternoon on Rocky Linux or AlmaLinux to learn the Red Hat differences (dnf, firewalld, SELinux), and build a few Alpine containers. The core skills are the same everywhere.
Do I really need the command line, or can I use a GUI?
For learning, a desktop is fine. For DevOps work you need the command line: servers have no screen, you reach them over SSH, and automation (scripts, Ansible, CI pipelines) is just commands written down. Plan to be comfortable in a terminal by the end of this course.
Why do servers and containers run Linux instead of Windows?
Cost, size and tooling. Linux has no per-instance licence, minimal installs are tiny, and the container ecosystem (namespaces, cgroups, Docker, Kubernetes) was built on Linux. Windows servers and Windows containers exist and are the right choice for .NET Framework or Active Directory workloads, but they are the exception.
What is the difference between a terminal and a shell?
The terminal is the window that displays text and sends your keystrokes. The shell is the program inside it that interprets commands. bash is the default shell on most servers, zsh is the default on macOS, and sh is the minimal shell that portable scripts target.
How much Linux do I need before learning Docker or Kubernetes?
You should be able to move around the filesystem, read and edit files, understand permissions, inspect processes and ports, and read logs. That is lessons 1 to 10 of this course. Everything after that makes container and cluster problems much easier to debug.
Is it safe to practise on my own computer?
Yes, if you use the lab machine from this lesson. A Multipass VM, a WSL distribution or a container is isolated from your files, and you can delete it and start again in a minute. Avoid practising commands like rm -r or firewall changes on a machine you care about.