OnCallReadyStart learning

First Login: glossary

139 terms, in plain words, with where each one is taught.

.gitkeep
An empty placeholder file put in a directory so git records the directory. The name means nothing to git; it is a convention.
/dev
The directory where Linux shows devices - disks, terminals, /dev/null - as files. Lesson 1.20
/dev/null
A special file that swallows everything written to it. 2>/dev/null throws error messages away. Lesson 1.7
/etc/hosts (hosts file)
A local text file of name = address pairs, checked before DNS. Handy for giving a lab VM a name. Lesson 1.13
$PATH
The environment variable listing, separated by colons, the directories the shell searches for a command name you type. Lesson 1.9
absolute path (absolute paths)
A path that starts with /, so it means the same thing from anywhere: /var/log/syslog. Lesson 1.3
alias (aliases)
A shortcut name the shell expands into a longer command: ll means ls -alF. Defined in ~/.bashrc, and only in the shell you type into - not in scripts. Lesson 1.9
AMD
A chip maker. It designed the 64-bit version of the Intel-style CPU, which is why that architecture is also called amd64 (the same thing as x86_64). Lesson 1.1
apt (apt-get)
Ubuntu's tool for installing software (its package manager): apt update refreshes the list of what is available, apt install X installs X. Lesson 1.11.
arm64 (aarch64)
The CPU architecture of Apple Silicon Macs and phones. Ubuntu calls it arm64, the Linux kernel calls it aarch64 - same thing. Lesson 1.1
bash
The shell on the lab box and on most Linux servers: the program that reads what you type and runs it. The Mac uses zsh by default; everyday commands behave the same in both. Lesson 1.1
binary (binaries)
A compiled program file, like /usr/bin/ls, as opposed to a text script.
boot (booting, boot sequence)
Starting a machine, from power-on until you can log in. Lesson 1.15 walks through the steps: firmware, bootloader, kernel, initramfs, PID 1, services. Lesson 1.11
bootloader (GRUB, boot loader)
The program that loads the kernel from /boot and starts it. Ubuntu's is GRUB. Lesson 1.15
brace expansion
The shell turning {a,b,c} into three separate words before the command runs, so mkdir -p lab/{a,b,c} makes three directories. Lesson 1.5
builtin (builtins, shell builtin)
A command built into the shell itself rather than a separate program, like cd or echo. Errors from builtins start with bash:. Lesson 1.3
clone (git clone, cloned)
To copy a remote git repo, with its whole history, onto your machine. Lesson 1.17
comment (comments)
Text after # on a command line or in a script; the shell ignores it. Used for notes to humans. Lesson 1.5
commit (commits)
One saved snapshot in git, with a message and an author. git commit -m "message" makes one. Lesson 1.17
CPU architecture (architecture)
The family of instructions a CPU understands. A program built for one architecture does not run on another. uname -m prints it: aarch64 on the lab VM. Lesson 1.1
default route
The catch-all entry in the routing table: "anything not listed goes via this gateway". The default via ... line in ip r. Lesson 1.13
DHCP
How a machine asks the network for an address: a DHCP server hands out an IP address, the gateway, DNS servers and a lease time. Lesson 1.13
disk (disks, block device, block devices)
A storage device. Linux shows disks as files in /dev, like /dev/vda; lsblk lists them. Lesson 1.1
distribution (distro, distributions, distros)
A packaged version of Linux: the kernel plus a chosen set of tools and settings, made by one team. Ubuntu, Debian and Red Hat are distributions. Lesson 1.1
dotfile (dotfiles, hidden file, hidden files)
A file whose name starts with ., which ls skips unless you add -a. Hidden only by convention - not protected. Lesson 1.3
ed25519
The modern key type (algorithm) for SSH keys: short, fast and strong. ssh-keygen -t ed25519 makes one. Lesson 1.17
ELF
The file format of compiled Linux programs. file reports a program as "ELF 64-bit ... executable". Lesson 1.3
Emulate (emulation)
Running a VM for a different CPU architecture by translating every instruction in software. It works, but several times slower than virtualizing. Lesson 1.1
enp0s1
The lab VM's network interface name: en Ethernet, p0 PCI bus 0, s1 slot 1. Named after where the card sits, so it never changes. Lesson 1.13
environment variable (environment variables, env var, env vars)
A variable the shell passes to every program it starts, like HOME, USER or PATH. Lesson 1.9
Ethernet
The standard wired network type. The en in enp0s1. Lesson 1.13
exit status (exit code, exit codes, exit statuses)
The number every command returns when it ends: 0 means success, anything else means failure. The shell keeps the last one in $?. 126 = cannot execute, 127 = command not found, above 128 = killed by signal (status - 128): 130 Ctrl+C, 137 SIGKILL, 143 SIGTERM. Lesson 1.7
ext4
The standard Linux filesystem, used on the lab box's /, /data and /srv/cache. Lesson 1.20
filesystem (filesystems, file system)
The structure written onto a partition or volume that turns raw space into files and directories. Ubuntu's usual one is ext4. Lesson 1.20
fingerprint (fingerprints, key fingerprint)
A short hash of a key, like SHA256:+DiY3..., used to compare keys quickly by eye. Lesson 1.17
firmware (UEFI)
The small program built into a machine that runs at power-on and hands over to the bootloader. Lesson 1.15
fstab (/etc/fstab)
The file /etc/fstab, listing which disks to mount where at every boot. Lesson 1.15
gateway (default gateway, router)
The machine that forwards traffic to other networks. The lab VM's gateway is your Mac, 10.64.0.1. Lesson 1.13
git
A version-control tool: it records snapshots (commits) of a set of files so you can see and undo every change. Lesson 1.3
git remote (remotes, origin)
Another copy of a git repo, usually on a server like GitHub. The default one is named origin; git remote -v shows its URL. Lesson 1.17
GitHub
A website that hosts git repositories. You push to it over SSH with a key. Lesson 1.17
glob (globs, wildcard, wildcards)
A pattern for file names: * means "any characters", so *.log matches every name ending in .log. The shell replaces it with the matching names. Lesson 1.5
GNU (GNU project)
A free-software project that wrote most of the standard Linux command-line tools (bash, grep, sed, ls...). "GNU grep" means that project's version of grep. Smaller systems (Alpine, BusyBox) ship different versions of the same tools, with fewer options. Lesson 1.17
GPG (GnuPG, GPG key, GPG keys)
GNU Privacy Guard: a tool for signing and encrypting with key pairs. GitHub uses GPG keys to show a commit really came from you; the SSH key is what lets you push. Lesson 1.17
group (groups)
A named set of users who share access. Every file belongs to one group, and the middle rwx in ls -l says what that group may do. Lesson 1.3
guest (guest OS)
The computer running inside a VM, as opposed to the real host underneath. For your lab, the guest is the Ubuntu VM. Lesson 1.1
GUI
Graphical user interface: windows, icons and a mouse pointer. Ubuntu Server has none - everything is done by typing commands. Lesson 1.1
hash (hashes, hashed, SHA256)
A short fixed-size string computed from some data; change even one bit of the data and the hash changes completely. SHA256 is a common method. Lesson 1.17
history (command history)
The list of commands you typed before. Up/Down walk it, history prints it, !! repeats the last one. Lesson 1.7
host (host machine)
The real computer a VM runs on. For your lab, the host is your Mac. Also used more loosely for "any machine on a network", as in "ssh to that host". Lesson 1.1
host key (host keys)
A server's own key pair, which proves to you that you reached the real server and not an impostor. Lesson 1.17
hostname
A machine's name, like oncall-lab. It appears after the @ in the prompt; the hostname command prints it. Lesson 1.1
HTTPS
The encrypted web protocol. A git remote starting https:// logs in with a username and password or token instead of an SSH key.
hypervisor (hypervisors)
The program that creates and runs VMs, sharing out the real CPU, memory and disk between them. On your Mac that is UTM, which uses QEMU underneath. Lesson 1.1
initramfs
A tiny starter system the kernel unpacks into memory at boot; its only job is to find the real disk and mount it. Lesson 1.15
inode (inodes)
The small record a filesystem keeps for each file (owner, permissions, where its data is). There is a fixed number, so a filesystem can run out of inodes while space is left. df -i shows them.
IP address (IP addresses, IP)
A machine's number on a network, like a phone number. The lab VM is 10.64.0.2. Lesson 1.13
IPv4
The common kind of IP address: four numbers from 0 to 255, like 10.64.0.2. Lesson 1.13
IPv6
The newer, longer kind of IP address, written with colons, like fe80::3ca1:5cff:fe77:2b09. Lesson 1.13
ISO (ISO image)
An installer image: one file containing a whole install disc. You downloaded the arm64 Ubuntu Server ISO to create the VM. Lesson 1.1
kernel (the kernel)
The core program of an OS: it talks to the hardware and decides which program gets the CPU, memory and disk. Every other program asks the kernel for things. uname -r prints the running kernel version. Lesson 1.1
key pair (SSH key, SSH keys, key pairs)
Two matching keys made together: a private one you keep secret and a public one you give out. SSH uses them to log in without a password. Lesson 1.17
known_hosts
The file ~/.ssh/known_hosts, where SSH saves the host keys you trusted. A changed key for a known host triggers a loud warning. Lesson 1.17
launchd
The Mac's equivalent of systemd: the first program macOS starts, which starts and looks after all the others. Lesson 1.1
lease (DHCP lease)
How long a DHCP address is yours before the machine must ask again. Addresses can change when a lease is not renewed. Lesson 1.13
library (libraries)
Shared code that many programs use. On Ubuntu, library packages usually have names starting with lib. Lesson 1.11
How many names point at a file or directory - the second column of ls -l. A directory has at least 2: its name in the parent and its own .. Lesson 1.3
loopback (lo, 127.0.0.1, localhost)
A pretend network interface (lo, address 127.0.0.1) that never leaves the machine, so programs on it can talk to each other. Lesson 1.13
LUKS
Linux's standard disk encryption: the volume is unreadable until a passphrase unlocks it at boot. The lab VM does not use it. Lesson 1.20
LV (LVs, logical volume, logical volumes)
Logical volume: a slice cut from a VG, used like a partition but growable later. The lab box's / is on the LV ubuntu-lv. Lesson 1.20
LVM (Logical Volume Manager)
Logical Volume Manager: a flexible layer between partitions and filesystems. Partitions (PVs) are pooled into a group (VG), from which resizable volumes (LVs) are cut. Lesson 1.20
man page (man pages, manual page, manual pages)
The built-in manual for a command, opened with man name. It lists every option for the exact version installed. Lesson 1.9
mDNS (Bonjour, multicast DNS)
Multicast DNS: machines on the same local network announce their own names (ending in .local). Apple calls it Bonjour; Ubuntu Server does not do it by default. Lesson 1.13
mount (mounted, mounting, mounts)
To attach a disk (or other storage) to a directory of the tree, its mount point, so its files appear there. Lesson 1.20. Lesson 1.3
mount point (mount points, mountpoint)
The directory where a disk (or other storage) is attached to the file tree; its files appear under that directory. /data is a mount point on the lab box. Lesson 1.3
network interface (network interfaces)
One network connection as the OS sees it, with a name like enp0s1. ip -br a lists them. Lesson 1.13
NIC (network card, network interface card)
Network interface card: the hardware that connects a machine to a network. Lesson 1.13
octal (octal mode, octal notation)
Writing permissions as three digits: r=4, w=2, x=1, added up per group of three. rw-r--r-- is 644, rwxr-xr-x is 755. Lesson 1.3
OpenSSH (OpenSSH server, sshd)
The standard SSH software. Its server part (sshd) runs on the VM and accepts the SSH connections you make from the Mac. Lesson 1.1
orphan (orphans, orphaned)
A process whose parent died first. The kernel gives it to PID 1 as its new parent. Lesson 1.15
OS (operating system, operating systems)
The base software that runs a computer and everything on it: macOS on your Mac, Ubuntu Linux on the VM. Lesson 1.1
owner (file owner)
The user a file belongs to. Every file has exactly one owner, shown in the third column of ls -l. Lesson 1.3
package (packages)
An installable bundle of software: a program, its files, and a list of other packages it needs. On Ubuntu, apt installs them. Lesson 1.9
package manager (package managers)
The tool that installs, upgrades and removes packages and remembers what came from where. Ubuntu's is apt. Lesson 1.11
pager
A program that shows long text one screen at a time (less). Space pages down, /word searches, q quits. Lesson 1.9
parent process (PPID, child process)
Every process is started by another one, its parent; the new one is the child. PPID is the parent's PID. Lesson 1.15
partition (partitions)
A fixed section a disk is divided into, each used separately. vda1, vda2, vda3 are the lab disk's partitions. Lesson 1.20
passphrase
A password that encrypts your private key file, so a stolen copy is useless without it. Lesson 1.17
PCI (PCI bus)
The internal connector system cards plug into: numbered buses with numbered slots. lspci lists what is plugged in. Lesson 1.13
permissions (permission bits, file mode)
Who may do what with a file: read (r), write (w), execute (x), for the owner, the group, and everyone else - the nine letters in ls -l. Lesson 1.3
personal access token (access token, PAT)
A long random password you generate on GitHub, used instead of your account password for git over HTTPS. It expires.
PID 1 (init, init system)
The first process the kernel starts at boot (on Ubuntu: systemd). Ancestor of every other process; it adopts orphans and cannot be killed. Lesson 1.15
pipeline (pipelines)
Several commands joined with |, each one's output feeding the next one's input. Its exit status is the last command's. Lesson 1.7
predictable interface naming (predictable interface names)
Naming network interfaces after their hardware position (enp0s1) instead of the order they were found (eth0), so names never swap. Lesson 1.13
prefix length (/24, netmask, CIDR)
The number after the / in 10.64.0.2/24: how many leading bits name the network. /24 means the first three numbers are the network and the last one is the machine. Lesson 1.13
private key (private keys, id_ed25519)
The secret half of a key pair. It never leaves your machine and must be readable only by you (mode 600). Lesson 1.17
public key (public keys, id_ed25519.pub)
The shareable half of a key pair (the .pub file). You give it to GitHub or a server; it can check your signatures but not make them. Lesson 1.17
push (git push, pushed)
To send your new commits from your machine to the remote repo. Lesson 1.17
PV (PVs, physical volume, physical volumes)
Physical volume: a partition handed over to LVM. On the lab box, vda3. Lesson 1.20
qcow2
The disk-image file format UTM/QEMU uses: the VM's whole disk as one file on the Mac, which grows as the VM writes. Lesson 1.20
QEMU
The open-source hypervisor UTM uses underneath to run VMs. Lesson 1.1
reap (reaps, reaping)
To read a finished child's exit status, which removes it from the process list. PID 1 reaps the orphans it adopted. Lesson 1.15
recursive (recursively)
Acting on a directory and everything inside it, all the way down. -r (or -R) on cp, rm and ls. Lesson 1.5
relative path (relative paths)
A path that does not start with /; it is taken from the working directory. log/syslog means different files depending on where you stand. Lesson 1.3
repo (repos, git repository)
Short for repository: a directory whose history git tracks, in a hidden .git directory inside it. Lesson 1.17
repository (repositories)
A place that stores things for others to fetch. For apt: a server holding packages. For git (lesson 1.17): a project's tracked files and their history. Lesson 1.11
routing table
The list saying which network traffic goes where. ip r prints it. Lesson 1.13
RSA
The older key type for SSH keys. It still works, but its keys are long and need a big size (3072 bits or more) to be safe; ed25519 is the better default. Lesson 1.17
SIGINT
Signal 2, "interrupt": what Ctrl+C sends. A program killed by it exits with status 130. Lesson 1.7
SIGKILL (kill -9)
Signal 9, "die now": the program cannot refuse or clean up. Killed by it = exit status 137. Lesson 1.7
signal (signals)
A short numbered message the kernel delivers to a running program, like "stop now" or "please exit". Chapter 3 covers them. Lesson 1.7
signature
A stamp made with a private key that anyone with the matching public key can check. It proves you hold the private key without revealing it. Lesson 1.17
SIGTERM
Signal 15, a polite "please exit". The program may clean up first. Killed by it = exit status 143. Lesson 1.7
SSH (Secure Shell, ssh)
Secure SHell: an encrypted connection that carries your typing to a shell on another machine and its output back. ssh [email protected] opens one. It is a remote command line, not a remote screen. It can also log you in with a key pair instead of a password (lesson 1.17). Lesson 1.1
staged (staging area, git add)
Marking changes to go into the next commit, with git add. Only staged changes are committed. Lesson 1.17
stderr (standard error)
File descriptor 2: where a program writes errors. Also shown on the screen, but separate from stdout: > does not capture it, 2> does. Lesson 1.7
stdin (standard input)
File descriptor 0: where a program reads its input - your keyboard, a file (<), or the previous command in a pipe. Lesson 1.7
stdout (standard output)
File descriptor 1: a program's normal output. Goes to the screen unless redirected (>) or piped (|). Lesson 1.7
subnet (subnets, local network)
A group of addresses that can reach each other directly, written as address/prefix: 10.64.0.0/24 covers 10.64.0.0 to 10.64.0.255. Lesson 1.13
A tiny file that just points at another path, like a shortcut. ls -l shows it with type l and name -> target. Lesson 1.3
sysctl
Kernel tuning knobs, set at boot from files in /etc/sysctl.d/, and the sysctl command that reads and changes them.
tee
A command that copies its input into a file and to the screen. echo x | sudo tee /etc/f is how you write a root-owned file. Lesson 1.11
thick provisioning
Reserving a virtual disk's full size up front. Predictable, but you pay for the empty space immediately. Lesson 1.20
thin provisioning (thin-provisioned)
Giving a virtual disk real storage only as data is written. Saves space and allows promising more than exists, at the risk of everything filling up at once. Lesson 1.20
tmpfs
A filesystem that lives in memory, not on disk, so its files vanish at reboot. /run is one. Lesson 1.20
trust on first use (TOFU)
SSH's approach: the first time you connect you check and accept the server's key; after that any change is flagged. Lesson 1.17
Ubuntu Server (Ubuntu)
The Ubuntu distribution without a desktop: made to be run and managed from the command line, usually over SSH. Lesson 1.1
UID (user ID, uid)
The number that identifies a user. learner is 1000, root is 0, and the kernel checks the number, not the name. Lesson 1.11
Unix
An older operating system family that both Linux and macOS descend from, which is why basic commands like ls and cd work on both. Lesson 1.1
UTM
A free Mac app that runs virtual machines. Your lab VM runs in it. Lesson 1.1
vda (vdb, vdc)
The lab VM's first virtual (virtio) disk, /dev/vda. vdb and vdc are its second and third disks. Lesson 1.20
version control
Keeping a recorded history of every change to a set of files, so you can compare, share and undo. git is the standard tool. Lesson 1.17
VG (VGs, volume group, volume groups)
Volume group: LVM's pool of space, made from one or more PVs. On the lab box, ubuntu-vg; sudo vgs shows how much is still free. Lesson 1.20
virtio
Virtual devices designed for VMs: the guest knows they are virtual and talks to the hypervisor directly, which is much faster. The "v" in vda. Lesson 1.20
Virtualize (virtualization)
Running a VM whose CPU architecture matches the host's, so its instructions run directly on the real CPU at near-native speed. Lesson 1.1
VM (virtual machine, VMs, virtual machines)
A whole pretend computer - its own CPU, memory and disk - that runs as a program on a real computer. Your lab oncall-lab is a VM running inside UTM on your Mac. hostnamectl admits it: Virtualization: qemu. Lesson 1.1
working directory (current directory, cwd)
The directory your shell is currently "standing in". Relative paths start from here; pwd prints it.
x86_64 (amd64, x86)
The CPU architecture of Intel and AMD chips, used by most servers. Also called amd64. Lesson 1.1
zombie (zombies, defunct)
A finished process still listed because its parent has not yet read its exit status. Uses no CPU or memory; chapter 3 shows one. Lesson 1.15