What Is Linux: Kernel, Distributions and the File System Explained

Linux is an open-source operating system kernel around which complete systems are built: servers, desktops and embedded devices. When people say "a Linux server", they mean not one program but a distribution: the kernel plus utilities, libraries, a package manager and an init system. Let's look at what Linux really is, what it consists of and why almost every DevOps engineer relies on it.

Linux is the kernel, not the whole system

Strictly speaking, Linux is only the kernel. The kernel is the program that starts first after the bootloader and stays in memory for as long as the computer runs. It shares processor time between processes, allocates memory, works with disks and network cards through drivers, and enforces access rights.

Ordinary programs do not touch the hardware directly. When an editor saves a file, it makes a system call (open, write, close), and the kernel decides which disk block to write to and whether the process is allowed to do it. This separation makes the system stable: a crashed program does not bring down the whole computer.

You can check the kernel version with one command:

$ uname -r
6.8.0-45-generic

Linus Torvalds created the kernel in 1991, and since then it has been developed in the open: the source code is distributed under the GNU GPL version 2, and anyone can read, modify and redistribute it on the same terms.

What a Linux distribution is

A kernel alone is not enough: you need a shell to type commands, file utilities, libraries and a software installer. Most of the basic tools (ls, cp, bash, grep) come from the GNU project, which is why the system is sometimes called GNU/Linux. The kernel together with this set of software, assembled and tested as one unit, is called a distribution.

Distributions differ mainly in their package manager, update policy and target audience.

You can find out which distribution you have from the file /etc/os-release:

$ cat /etc/os-release
PRETTY_NAME="Ubuntu 24.04.1 LTS"
NAME="Ubuntu"
VERSION_ID="24.04"
ID=ubuntu
ID_LIKE=debian

For learning and servers, Ubuntu LTS or Debian are the most common choices: they have plenty of documentation, and commands from online guides almost always work without changes.

How the system is organized: kernel, shell, user space

It helps to think of Linux in layers. At the bottom is the hardware. Above it sits the kernel. Above that is user space: system services, libraries (for example glibc) and programs. Between you and the system is the shell — usually bash — which accepts commands and launches programs.

• Kernel — processes, memory, file systems, networking, drivers.
• Init system — the first process, with PID 1; on most modern distributions this is systemd. It starts the other services.
• Services (daemons) — web server, SSH server, cron, logging.
• Shell and utilities — what you work with in the terminal.

Servers usually have no graphical interface at all: the administrator connects over SSH and works at the command line. That is why learning Linux is first of all learning the terminal.

Linux file system: everything starts at the root /

Linux has no drive C: or D:. There is one directory tree that starts at the root — /. All disks, USB drives and network shares are attached (mounted) to some directory in this tree. Another principle: almost everything in Linux is represented as a file — regular files, directories, devices, even information about processes.

$ ls /
bin   dev  home  lib64  mnt  proc  run   srv  tmp  var
boot  etc  lib   media  opt  root  sbin  sys  usr

The layout of directories is described by the FHS (Filesystem Hierarchy Standard), so in any distribution configuration files live in roughly the same places.

Absolute and relative paths

An absolute path starts with / and does not depend on where you are: /var/log/syslog. A relative path is counted from the current directory: ../logs/app.log. The dot . is the current directory, two dots .. is the parent, and the tilde ~ is your home directory.

$ pwd
/home/alice
$ cd /var/log
$ cd ..
$ pwd
/var
$ cd ~
$ pwd
/home/alice

/proc: the system as a set of files

The /proc directory is not stored on disk — the kernel generates it on the fly. For example, cat /proc/cpuinfo shows the processors, cat /proc/meminfo shows memory, and every process has a directory /proc/<PID> with its command line and open files. Many tools such as ps and top simply read these files.

Mounting

The command df -h shows which file systems are mounted where and how much space they have:

$ df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda2        40G   12G   26G  32% /
/dev/sda1       1.1G  6.1M  1.1G   1% /boot/efi
tmpfs           393M  1.2M  392M   1% /run

Permanent mount points are described in /etc/fstab — the system reads this file at boot.

How Linux boots: from power-on to the login prompt

Understanding the boot process helps when a server "does not come up" after a reboot. In simplified form the chain looks like this:

1. Firmware (UEFI or BIOS) checks the hardware and finds the bootloader.
2. The GRUB bootloader shows a menu and loads the kernel from /boot and the initramfs image into memory.
3. The kernel initializes the hardware and, with the help of initramfs, finds and mounts the root file system.
4. systemd starts as the process with PID 1 and launches services in the right order: network, logging, SSH, cron and the rest.
5. The login prompt appears on the console or over SSH.

Kernel messages from boot can be viewed with sudo dmesg or journalctl -k, and the boot time by stage with systemd-analyze.

Users and permissions — built-in protection

Linux is a multi-user system from the start. Every file has an owner, a group and read, write and execute permissions. A regular user cannot damage system files, and administrative actions are performed through sudo. The superuser root can do anything, so working as root all the time is not considered good practice.

$ ls -l /etc/passwd
-rw-r--r-- 1 root root 2847 Oct  1 10:12 /etc/passwd

Reading this line: a regular file; the owner root can read and write it; everyone else can only read it.

Why a DevOps engineer needs Linux

For a DevOps engineer Linux is not just one topic among others but the environment where almost all the work happens. Here is where they meet it every day:

• Servers. Web servers, databases and queues run on Linux in the vast majority of cases.
• Containers. Docker uses kernel mechanisms of Linux — namespaces and cgroups. A container is a Linux process with isolation, and an image is based on a distribution such as Debian or Alpine.
• Clouds and Kubernetes. Cloud virtual machines and cluster nodes are also Linux.
• CI/CD. Builds in pipelines run on Linux runners, and build scripts are written in bash.
• Diagnostics. When a service fails, the answer is found in journalctl, top, ss, df — without knowing these tools, incident analysis is impossible.

The minimum set of skills: moving confidently through the file system, understanding permissions, installing packages, managing services with systemctl, reading logs, working with processes, networking and SSH, and writing simple bash scripts.

How to start learning Linux

You do not have to replace your main system with Linux. There are several safe ways to try it:

• Virtual machine (VirtualBox, VMware) with Ubuntu Server — you can break it and restore it from a snapshot.
• WSL on Windows — a full Ubuntu environment in the Windows terminal: wsl --install.
• Cloud server — the closest option to real work, connected over SSH.
• Docker container — docker run -it --rm ubuntu bash gives you a shell in seconds.

Start with navigation (pwd, ls, cd), then files and permissions, then packages, processes and services. Built-in help is always at hand: man ls or ls --help.

Summary

Linux is the kernel, and a distribution is the kernel together with utilities, libraries, a package manager and systemd. The whole system is one directory tree from the root /, where configuration lives in /etc, logs in /var/log, and programs in /usr. Understanding what Linux is and how it boots gives you the foundation for servers, containers and clouds. File systems, boot and administration are covered step by step in our Linux course.