DevOps

Linux Fundamentals

The filesystem, the shell, files and permissions, processes and text processing — the ground floor of every DevOps job.

1. Module 1

   Filesystem & Navigation

   Where things live in Linux, and how to move around without a mouse.

   1. 1.1✓What Linux is, and what a shell isBefore you type a single command, get clear on what you are typing into — and why professionals do it without a mouse.8 min
   2. 1.2✓Where am I? pwd, ls and cdThree commands do most of the moving around anyone ever does in a shell. This lesson is where you start typing.14 min
   3. 1.3✓The map of a Linux systemOne tree, starting at a single slash. Learn where things live and you stop guessing where to look when something breaks.16 min
   4. 1.4✓Absolute and relative pathsOne leading slash changes the meaning of everything after it. This is the rule people think they know and then get wrong at the worst possible moment.15 min
   5. 1.5✓Reading files without an editorcat, head, tail, less and file. Four ways to look inside something and one way to find out what it is before you try.15 min
   6. 1.6✓Capstone: find the failureA server is returning errors and nobody has told you where to look. Everything you need you already learned in this module.20 min
2. Module 2

   Files & Permissions

   Creating, copying and moving files — and who is allowed to do what.

   1. 2.1✓Copying, moving and deletingcp, mv and rm. Two of them are ordinary. The third has no undo, and knowing exactly what it does is the difference between a routine day and a very bad one.16 min
   2. 2.2✓Reading permissionsThat -rw-r--r-- you have been reading past since lesson 1.2. Nine characters, three questions, and one number that means the same thing.16 min
   3. 2.3✓Changing permissions with chmodTwo notations for the same command, and the one moment where a permission bit stops being theory — making a script executable and watching it run.15 min
   4. 2.4✓Owners, groups and sudoPermissions decide what an owner may do. This lesson is about who the owner is, how to change that, and why only root is allowed to.15 min
   5. 2.5✓Capstone: the deploy that will not deployA deploy failed last night. There are three separate permission problems on this machine and the log only mentions one of them.20 min
3. Module 3

   Users, Groups & sudo

   Identity on a Linux box, and why you should not live as root.

   1. 3.1✓Who is on this machineA server has thirty accounts and one person. This lesson is about reading the file that lists them, and about why most of the names in it are not people at all.14 min
   2. 3.2✓Creating and removing accountsuseradd writes one line to one file. Everything that goes wrong afterwards comes from the two options people leave off, so this lesson is mostly about those.16 min
   3. 3.3✓Groups that actually workModule 2 said "put the user in a group" and moved on. Here is the part it skipped — building a shared directory that still works on the second day.18 min
   4. 3.4✓sudo, properlyYou have been typing sudo since Module 2 without knowing what it checks. It reads a file, that file can be edited badly enough to lock you out, and there is a command whose whole job is to stop you doing that.18 min
   5. 3.5✓Capstone: onboarding an engineerA ticket, a machine, and a colleague who starts on Monday. Everything in this module, in the order you would actually do it, with no command given to you.25 min
4. Module 4

   Text Processing & Pipes

   grep, sort, cut and the pipe — turning output into answers.

   1. 4.1✓Pipes and the three streamsEvery command has one input and two outputs. Once you can see those, the pipe stops being punctuation and becomes the reason the whole toolkit works.16 min
   2. 4.2✓grep: finding the line that mattersA log is too long to read and exactly the right length to search. grep is the difference — including the one thing about its patterns that silently gives everybody the wrong answer.18 min
   3. 4.3✓find: locating the file itselfgrep searches inside files. find searches for them. Its argument syntax is unlike every other command, and once that clicks the rest is a list of tests.16 min
   4. 4.4✓Counting: cut, sort and uniqThe pipeline that answers questions no single line of the file contains. Four commands, one order, and one rule that everybody breaks the first time.18 min
   5. 4.5✓Capstone: reading an outageCheckout broke at 09:11 and nobody has looked yet. Four log files, three commands you now know, and a written finding at the end — which is the part that actually gets read.25 min
5. Module 5

   Processes & Services

   What is running, why it stopped, and how systemd keeps it alive.

   1. 5.1✓What is runningFour modules about files. This one is about the things that open them — and about the fact that most of what runs on a server was never started by a person.16 min
   2. 5.2✓Signals: asking, and insistingkill is badly named. Most signals are a polite request, one of them is not, and the difference between them is the difference between a clean shutdown and a corrupt file.16 min
   3. 5.3✓Services and systemdNobody starts a web server by typing its name. They write a unit file — and the difference between started and enabled is the mistake that survives until the next reboot.18 min
   4. 5.4✓The journalFour modules of grepping log files, and then a log you cannot cat. journalctl is not an inconvenience — it is a query language, and the reason it exists is worth understanding.16 min
   5. 5.5✓Capstone: the service that will not startA handover note, three services, and two faults — one loud and one that will not show itself until the next reboot. Everything in this module, with nothing pointed out.25 min
6. Module 6

   Package Management

   Installing and updating software the way servers do.

   1. 6.1✓What a package actually isSoftware on a server is not an application you download. It is a set of files, a list of what those files are, and a record that says where they came from — and that record is a text file you can read.16 min
   2. 6.2✓apt update, and what the machine knowsA server does not know what software exists. It knows what it was last told, and on most machines that was a long time ago — which is why apt install fails on packages that plainly exist.20 min
   3. 6.3✓Dependencies, and the binary somebody downloadedYou ask for one package and three arrive. apt remembers which ones you wanted and which ones came along — and that memory is the difference between a server you can clean up and one you cannot.18 min
   4. 6.4✓Removing, purging and upgradingremove and purge look interchangeable until the day they are not. And an upgrade that silently kept your edited config file did not do it by luck — it did it by checksum.20 min
   5. 6.5✓Capstone: bring the server back under managementweb-01 works perfectly. It is also a year out of date, running software no package manager knows about, and carrying a library nothing has needed since 2023. Three faults, no error messages.30 min
7. Module 7

   Networking Basics

   Ports, DNS, SSH and the handful of commands that debug most outages.

   1. 7.1✓Addresses, interfaces and routesA server has more than one address, and they mean different things. Knowing which is which is the difference between "the service is up" and "the service is reachable".16 min
   2. 7.2✓Ports, and what a service is listening onThe API is running. systemctl says active, the logs are clean, and it answers perfectly on the server. From anywhere else it does not exist — and one column of ss output says why.20 min
   3. 7.3✓Names, and when they liedig says the name points here. The machine connects somewhere else. Both are telling the truth, and the file that explains the difference is one nobody thinks to look at.18 min
   4. 7.4✓Firewalls, and the silence they causeufw does not refuse a connection. It says nothing at all — and that silence is the clearest signal you get, once you know how to read it.18 min
   5. 7.5✓Capstone: the API nobody can reachThree faults, one symptom, and no error message anywhere. Fixing any one of them changes nothing you can see — which is exactly why this is the shape of a real network problem.30 min
8. Module 8

   Shell Scripting

   Turning the commands you now know into repeatable scripts.

   1. 8.1✓Your first scriptYou have been writing scripts for seven modules without saving any of them. A script is nothing more than the commands you already type, in a file, with permission to run.16 min
   2. 8.2✓Decisions, and the number behind themThere are no booleans in the shell. `if` runs a command and looks at the number it left behind — and once you know that, `[` stops being punctuation and starts being a program.20 min
   3. 8.3✓Loops, arguments and the quotes that save themA script that only works on one directory is a note to yourself. Give it an argument and it becomes a tool — and then one file with a space in its name breaks it, unless you quoted.22 min
   4. 8.4✓Scripts that fail loudlyA shell script's default behaviour is to ignore errors and keep going. This machine has one that has printed "Backup complete" every night for a year while quietly missing the only directory anybody cared about.20 min
   5. 8.5✓Capstone: a backup you can trustRewrite the script that lied for a year. Twenty lines, every one of which you can now explain — and at the end of it, the course.30 min