DevOps Linux Basics Syllabus

Linux Basics syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Linux Basics in DevOps, not a summary of it.

1. 1

   File System

   3 topics

   • Directory structure
   • File types
   • File permissions
2. 2

   Commands

   2 topics

   • Basic commands
     • ls
     • cd
     • cp
     • mv
     • rm
     • mkdir
     • rmdir
   • Advanced commands
     • find
     • grep
     • awk
     • sed
3. 3

   Text Editors

   2 topics

   • vi, vim
   • nano
4. 4

   Processes

   2 topics

   • Listing processes
     • ps
     • top
   • Managing processes
     • kill
     • bg
     • fg
5. 5

   Users and Groups

   3 topics

   • Managing users
     • useradd
     • usermod
     • userdel
   • Managing groups
     • groupadd
     • groupmod
     • groupdel
   • Permissions
     • chmod
     • chown
6. 6

   Package Management

   2 topics

   • Debian-based
     • apt-get
     • dpkg
   • Red Hat-based
     • yum
     • rpm
7. 7

   System Monitoring

   1 topic

   • Tools
     • top
     • htop
     • iostat
     • vmstat
     • netstat
8. 8

   Shell Scripting

   2 topics

   • Shell Basics
     • Writing basic scripts
     • Using variables
     • Control structures: if statements, loops
   • Advanced Scripting
     • Functions
     • Error handling
     • Command-line arguments
     • Input/output redirection
9. 9

   Networking in Linux

   2 topics

   • Networking Commands
     • ifconfig
     • ip
     • ping
     • netstat
     • ss
     • traceroute
     • nslookup
   • Network Configuration
     • Configuring network interfaces
     • Setting up static IP addresses
     • Configuring DNS

Linux Basics flashcards for DevOps

25 of 51 cards from the Linux Basics deck — real questions with worked answers.

1. In the Linux Filesystem Hierarchy Standard (FHS), what is the purpose of the root directory `/`?

   It is the top-level directory of the entire filesystem tree; every other file and directory descends from it. There is exactly one root, and absolute paths begin with `/`.

2. What is stored in `/bin` and `/sbin` versus `/usr/bin` and `/usr/sbin`?

   `/bin` holds essential user command binaries and `/sbin` holds essential system/administration binaries needed for booting and single-user mode. `/usr/bin` and `/usr/sbin` hold non-essential user and system binaries. On modern distros `/bin` and `/sbin` are usually symlinks into `/usr`.

3. What is the difference between `/etc`, `/var`, and `/tmp` in the Linux directory structure?

   `/etc` stores system-wide configuration files (static). `/var` stores variable data that changes during operation (logs, mail, spool, caches). `/tmp` stores temporary files, often cleared on reboot.

4. What does `/proc` represent in Linux?

   `/proc` is a virtual (pseudo) filesystem exposing kernel and process information as files. For example, `/proc/cpuinfo`, `/proc/meminfo`, and `/proc/<pid>/` directories for each running process. It exists in memory, not on disk.

5. What is the purpose of `/home`, `/root`, and `/boot`?

   `/home` contains regular users' personal directories. `/root` is the home directory of the root (superuser) account. `/boot` contains static files needed to boot the system, including the kernel (`vmlinuz`) and bootloader (GRUB) files.

6. List the seven Linux file types and the character `ls -l` uses to denote each.

   Regular file `-`, directory `d`, symbolic link `l`, character device `c`, block device `b`, named pipe (FIFO) `p`, and socket `s`.

7. What is the difference between a hard link and a symbolic (soft) link in Linux?

   A hard link is an additional directory entry pointing to the same inode; it shares the inode and breaks only when all links are removed, and cannot cross filesystems or link directories. A symbolic link is a separate file containing a path to the target; it can cross filesystems and link directories but breaks if the target is deleted (dangling link).

8. In Linux file permissions, what numeric values are assigned to read, write, and execute?

   Read $r = 4$, write $w = 2$, and execute $x = 1$. Permissions for each class are summed, so e.g. $rwx = 4+2+1 = 7$ and $r{-}x = 4+1 = 5$.

9. Decode the octal permission `755`: what access does each class (owner, group, other) have?

   Owner has $7 = rwx$ (read, write, execute); group has $5 = r{-}x$ (read, execute); other has $5 = r{-}x$ (read, execute). Common for executable scripts and directories.

10. What three permission classes does every Linux file have, and in what order does `ls -l` show them?

    Owner (user, `u`), group (`g`), and other/everyone else (`o`). `ls -l` shows them left to right after the file-type character: owner triplet, group triplet, other triplet (e.g. `-rwxr-xr--`).

11. How do `chmod` symbolic mode operators `+`, `-`, and `=` differ?

    `+` adds the specified permissions, `-` removes them, and `=` sets exactly those permissions (clearing the others). Example: `chmod u+x file` adds execute for the owner; `chmod go= file` removes all permissions for group and other.

12. What does the `umask` value do, and what default permissions result from a umask of `022`?

    `umask` defines permission bits to remove from the default. Files default to $666$ and directories to $777$. With umask $022$: files become $666 - 022 = 644$ (`rw-r--r--`) and directories become $777 - 022 = 755$ (`rwxr-xr-x`).

13. What are the three special permission bits in Linux and their octal values?

    setuid ($4000$): a program runs with the file owner's privileges. setgid ($2000$): a program runs with the group's privileges, or new files in a directory inherit its group. Sticky bit ($1000$): in a shared directory, only a file's owner (or root) can delete it (e.g. `/tmp`).

14. What command changes a file's owner and group, and what is the syntax to set both at once?

    `chown`. Syntax: `chown user:group file`. To change only the group you can use `chown :group file` or the dedicated `chgrp group file`. Add `-R` for recursive on directories.

15. Name the basic Linux commands to list directory contents, print the working directory, and change directory.

    `ls` lists directory contents, `pwd` prints the current working directory's absolute path, and `cd` changes the current directory.

16. What do the commands `cp`, `mv`, and `rm` do, and which flag makes them recursive?

    `cp` copies files/directories, `mv` moves or renames, and `rm` deletes. The `-r` (or `-R`) flag makes `cp` and `rm` operate recursively on directories; `mv` handles directories without a recursive flag.

17. What is the difference between `cat`, `less`, `head`, and `tail`?

    `cat` concatenates and prints whole files. `less` is a pager for scrolling through output interactively. `head` shows the first lines (default 10), and `tail` shows the last lines (default 10); `tail -f` follows a file as it grows.

18. What does `grep` do, and what do the flags `-i`, `-r`, and `-v` mean?

    `grep` searches input for lines matching a pattern (regular expression). `-i` makes the match case-insensitive, `-r` searches recursively through directories, and `-v` inverts the match (shows non-matching lines).

19. Compare the advanced text-processing tools `find`, `sed`, and `awk`.

    `find` searches the filesystem for files matching criteria (name, type, size, time) and can act on them. `sed` is a stream editor for find-and-replace and line transformations. `awk` is a pattern-scanning and field-processing language ideal for columnar/structured text.

20. What do `tar`, `gzip`, and the combined `tar -czf` command do?

    `tar` bundles many files into a single archive (tarball). `gzip` compresses a single file. `tar -czf archive.tar.gz dir/` creates (`c`) a gzip-compressed (`z`) archive into a named file (`f`); extract with `tar -xzf`.

21. In the vi/vim editor, what are the three main modes and how do you switch between them?

    Normal (command) mode for navigation/commands, Insert mode for typing text, and Visual mode for selecting text. Press `i`/`a`/`o` to enter Insert mode, `v`/`V`/`Ctrl+v` for Visual mode, and `Esc` to return to Normal mode.

22. In vim's Normal mode, how do you save and quit, quit without saving, and force-quit?

    `:w` saves (write), `:q` quits, `:wq` or `ZZ` saves and quits, `:q!` quits discarding changes, and `:x` saves only if changes were made.

23. What is the difference between vi and vim?

    `vi` is the original POSIX visual editor. `vim` (Vi IMproved) is a backward-compatible enhanced version adding syntax highlighting, multi-level undo, split windows, plugins, visual mode, and much more. On many systems `vi` is a symlink to `vim`.

24. In the nano editor, what do the `^` and `M-` notations in the help bar mean, and how do you save and exit?

    `^` means the Ctrl key and `M-` means the Meta (usually Alt) key. Save (write out) with `Ctrl+O`, exit with `Ctrl+X`, and search with `Ctrl+W`.

25. Why is nano often preferred over vi/vim for beginners?

    nano is a modeless editor (no separate command/insert modes) that displays the most common keyboard shortcuts at the bottom of the screen, so you can type and edit immediately without learning special commands.

See more Linux Basics flashcards →

Planning Linux Basics for DevOps

Linux Basics (DevOps) FAQ