Lesson 01 beginner

Introduction to Linux

What Linux actually is, how the kernel, the distribution and the shell fit together, why almost every server, container and CI runner runs it, which distributions matter in 2026 and how to set up the free lab machine you will use for the rest of the course.

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:

PieceWhat it doesRestaurantExamples
KernelManages hardware, memory, processes and filesThe kitchen: nobody sees it, nothing works without itLinux 6.x / 7.x
DistributionBundles the kernel with tools, libraries, a package manager and a release scheduleThe whole restaurant: menu, staff, opening hoursUbuntu, Debian, RHEL, Rocky, Alpine
ShellReads the commands you type and starts programsThe waiter who takes your order to the kitchenbash, 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 /proc and /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:

FamilyDistributionsPackage managerWhere you meet it
DebianUbuntu, Debianapt (.deb packages)Cloud VMs, CI runners, most tutorials. Ubuntu 26.04 LTS is supported until 2031
Red HatRHEL, Rocky Linux, AlmaLinux, CentOS Stream, Fedoradnf (.rpm packages)Banks, telecoms, enterprises with support contracts. RHEL 10 is the current major release
AlpineAlpine LinuxapkContainer images: the base image is about 8 MB
OthersSUSE, Arch, Amazon Linux, Flatcar, Bottlerocketzypper, pacman, dnfSpecific 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-slim or 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, debian or alpine.
  • 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
...
  • whoami prints the user you are logged in as.
  • hostname prints the machine’s name.
  • uname -r prints the kernel version. Your number will differ; that is fine.
  • /etc/os-release describes the distribution. It exists on every modern distribution, so scripts read it to find out where they are running. ID_LIKE=debian tells 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:

  1. The kernel version and the distribution name, version and family.
  2. The number of CPU cores and the total and available memory.
  3. The shell you are using and how long the machine has been running.
  4. Bonus: start a throwaway alpine container (if you have Docker) and run the same cat /etc/os-release. Compare the ID and the size of the image with docker 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?

  1. The shell; you switch from bash to zsh
  2. The kernel; Ubuntu publishes an updated kernel package that you install and then reboot or live-patch
  3. The distribution’s logo and branding; nothing needs to change
  4. The terminal app on your laptop; you update it from the app store
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?

  1. Ubuntu, because it has the most packages
  2. RHEL, because it has ten years of support
  3. Alpine, but it uses musl instead of glibc, so some prebuilt binaries do not run
  4. CentOS Linux, because it is free
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?

  1. uname -r
  2. echo $SHELL
  3. cat /etc/os-release
  4. whoami
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.

↑ ↓ navigate Enter open Esc close