Peek Into NFS Mount Options
Quickly discover what options your NFS client actually uses and why it matters.
Archive
Keep what matters: rsync exclude patterns
Control what gets copied with rsync by excluding files and folders using patterns and lists.
Backup directory trees with rsync
Efficiently copy, sync and snapshot directory trees locally or over the network with rsync.
Test backup and restore with tar
A hands-on walk-through to create an archive, remove originals, restore files and verify integrity using tar.
Assemble RAID manually and recover a degraded array
Step through mdadm commands to inspect, assemble and mount a manual RAID recovery.
Monitor RAID rebuild progress
Practical commands and checks to watch Linux mdadm rebuilds in real time
Check RAID arrays with mdadm
Practical steps to inspect and troubleshoot Linux software RAID using mdadm.
Inspect AppArmor Logs: Find Why An App Is Blocked
Quickly locate AppArmor DENIED messages and turn them into actionable profile fixes.
Disable a specific AppArmor profile
Unload or switch a single AppArmor profile without disabling the whole LINUX security layer.
Active AppArmor Profiles: Inspect Kernel Enforcement
Quick commands to list which AppArmor profiles are loaded and whether they enforce or complain.
List all environment files for a service
Find every file that injects environment variables into a systemd service and inspect what actually reaches the process
Switch CPU Frequency Scaling Governor
Change the kernel governor to favor battery life or raw speed, right from the shell.
Check CPU Governors: Inspect and Adjust Linux Scaling
Quick commands to read available and active CPU governors and understand how they affect performance and power.
Choose the Right I/O Scheduler
Learn to inspect and switch Linux I/O schedulers for better disk performance and predictable latency.
View and Change Linux I/O Scheduler
Quickly read and adjust the block device scheduler to optimize I/O behavior.
Monitor disk temperatures with hddtemp
Practical steps to read and monitor HDD and SSD temperatures with hddtemp, from one-off checks to daemonized monitoring.
Check file descriptor limits
Quickly find per-process and system file descriptor limits and stop "Too many open files" from breaking services.
Which shared libraries are in use?
Quick, practical ways to see which shared libraries an executable or a running process has loaded.
Find who holds a file with lsof
Discover which process keeps files or sockets open and act on them quickly.
Test sshd configuration safely
Verify your OpenSSH daemon configuration quickly before restarting, to avoid lockouts and downtime.
Make Your Keyboard Layout Permanent on Linux
Set a system-wide keyboard layout once and keep it across boots, consoles and graphical sessions.
Inspect locale environment variables
Quick commands to reveal and verify the system locale and how it affects programs.
Convert text encoding with iconv
Quick, reliable conversions between character encodings on the command line.
Keep System Clocks Accurate: Check Timezone Database Updates
Quick, practical checks to see if your system's timezone database is up to date and why that matters.
Prevent file collisions with flock
Learn how to use the `flock` tool to serialize access to files and critical sections from shell scripts.
Set memory limits with cgroups
Practical steps to constrain process memory on Linux using cgroup v2 and v1 tools.
Set CPU shares with cgroups
Control how the kernel divides CPU time between groups of processes using cgroups so one workload cannot starve another.
Inspect processes in cgroups
Quickly find which processes live in which cgroup and verify resource containment.
Watch cgroups in action
Hands-on steps to create, limit and read cgroup resource metrics so you can watch a process under control.
Inspect the cgroup v2 hierarchy
Quickly verify that the kernel exposes a unified cgroup v2 mount, find available controllers and map processes into the hierarchy.
Inspect Memory Zones to Diagnose Fragmentation
See how to read per-zone information to find fragmentation, low watermarks and reclaim candidates.
Which filesystems can my Linux run?
Quickly discover kernel-supported and module-backed filesystems on your system.
Inspect Linux Kernel Build Options
Quick methods to read what features your running kernel was built with.
Inspect NIC Driver and Firmware on Linux
Quickly identify which kernel driver and firmware your network interface uses and why that matters.
Wake-on-LAN: Power PCs Remotely
Enable network wake-ups from Linux and control remote power with simple commands.
Tune NICs with ethtool for better throughput
Inspect and set NIC hardware parameters quickly from the shell to improve reliability and performance.
Check link negotiation speed
Quickly verify what speed and duplex your interface negotiated and act on mismatches.
Where Packets Vanish: Analyze Linux Network Buffers
Diagnose dropped packets and buffer pressure with practical commands and direct examples.
Quick Packet Snapshots with tshark
Capture and inspect network traffic instantly from the shell using tshark.
Capture Only DNS Traffic
Quick, precise packet captures that show only DNS activity so you can spot resolution problems fast.
Readable timestamps with tcpdump
Print human-friendly timestamps and inter-packet deltas with tcpdump, and see exact examples to reproduce.
Filter packets by port in tcpdump
Capture only the traffic you care about by filtering on ports with tcpdump, and speed up diagnosis.
Packet Sleuthing with tcpdump
Capture, filter and inspect packets on Linux from the terminal to find what the network is really doing.
Monitor network traffic with ip -s link
Quickly inspect per-interface packet and byte counters to spot errors, drops and traffic trends with a single command.
Enable IPv6 Privacy Extensions on Linux
Stop predictable IPv6 addresses from following your host across networks by enabling temporary addresses.
Inspect IPv6 routes and find next-hop
Quickly locate how Linux decides where IPv6 packets go and verify the next hop on the command line.
Manual subnet masking for Linux networks
Learn to compute IPv4 subnet masks by hand and verify results with simple Linux tools.
Tracepath: Map the Route to Any Host
Quickly discover hop-by-hop routes and path MTU without root privileges.
Find Network Packet Drops Quickly
Learn to spot where packets vanish on Linux using simple tools and clear commands.
Reserve a Static DHCP Address — Practical Example
Map a MAC to a predictable IP with concrete isc-dhcp-server and dnsmasq examples to follow.
Regenerate SSH host keys safely
When a host key is duplicated or suspected compromised, replace it quickly and safely to restore trust.
Inspect the inode table and measure usage
See live inode statistics and discover when metadata, not bytes, is the bottleneck.
Tune filesystem parameters with tune2fs
Inspect and adjust ext2/3/4 superblock settings for reliability and performance.
Check filesystem reserved blocks
Find and inspect the blocks reserved for root that keep a filesystem usable when it is nearly full.
Run SMART long self-test and catch failing disks
Use smartctl to run a SMART long self-test and inspect the results to detect disk media problems.
Monitor disk SMART health with smartctl
Inspect and run SMART checks from the shell to spot failing disks before data loss.
Temporarily Change the Linux Console Font
Swap the virtual console font for the current session with a single command and see the result immediately.
Where Your Keyboards Live
Find, peek and test the keymaps your Linux system can load, both for consoles and X.
Fine-Tune System Fonts on Linux
Configure system and user fonts, rebuild the font cache, and get consistent rendering on X11, Wayland and the console.
Check installed locales
Quickly discover which locales are installed and which one the system actually uses.
Analyze fork bomb behaviour safely
Safely reproduce and observe a fork bomb inside a controlled container and learn how to limit and mitigate its effects.
Discover user identity with id
Quickly inspect numeric and named user and group identities from the shell.
Craft Bash Login Scripts
Control which files bash reads at login to make environment, PATH and aliases persistent.
System-wide file-creation mask
Make new files start with predictable permissions by setting a global umask for logins and services.
Generate syslog messages with logger
Inject messages into the system log quickly for testing, monitoring and script annotations.
Export Systemd Journal Logs for Offline Analysis
Turn the binary systemd journal into portable files for forensic analysis, backups and secure transfer.
Inspect systemd journal rate limiting
Find when journald is dropping messages, see why, and tune the limits with a few commands.
Keep Systemd Journals Across Reboots
Enable and tune persistent systemd journals so logs survive reboots and disk pressure.
Is your systemd journal persistent? Quick checks and fixes
Hands-on commands to detect, verify and enable persistent systemd journal storage.
Keep Clocks Aligned with chronyd
Enable and configure chronyd to keep system time accurate even on flaky networks.
Master system time with timedatectl
Learn to inspect, correct and synchronize system time reliably using timedatectl and related tools.
Inspecting Time Drift on Linux Hosts
Quick methods to inspect and measure clock drift with built-in Linux tools.
Force the Clock: Manual System Time Sync
How to force an immediate time correction from the command line on Linux.
Inspect /etc/passwd User Records
See how Linux stores user account records and learn quick commands to inspect the format.
Manage shadow passwords: protect hashed secrets
How to audit, convert and control shadowed passwords for secure local authentication.
Check Assigned Groups with groups
Quickly reveal which groups a user belongs to using the simple "groups" command.
Switch groups with newgrp
Quickly become a different group in your shell to create or access group-owned resources.
Sticky bit protects shared directories
Make world-writable directories safe by limiting who can remove or rename files.
Tame background tasks with jobs
Practical job control for managing tasks started from your shell.
Spot zombies fast: find and clear defunct processes
Rapid commands to detect defunct "Z" processes and act on them.
See Active Kernel Threads on Linux
Quickly find and inspect the kernel threads running on your system using standard tools and /proc.
Manage TMP Cleanup Policies for Stability
Practical, hands-on ways to control how long files live in /tmp so services stay reliable.
Who’s Eating Your Disk? Inspect Home Directory Sizes
Practical command-line techniques to find which home folders and files consume your disk space.
Send kernel logs to any tty
Mirror kernel printk to a chosen virtual console and control what you see.
Verify Syslog Configuration Quickly
Hands on checks to prove your syslog is receiving, storing and forwarding logs.
Inspect Boot Logs to Diagnose Failures
Use journalctl, dmesg and systemctl to find what failed during boot and why.
Terminate an Entire Process Group Safely
Send a signal to a whole process group from the shell to stop related workers at once.
Find Process PIDs Fast with pidof
Quickly locate process IDs by name to inspect, signal, or troubleshoot services using the pidof utility.
Pinpoint Process CPU Usage
Measure which process consumes CPU and act fast on performance issues.
Adjust Process Priority with renice
Quickly change the niceness of running processes to manage CPU access and responsiveness.
Who's Nice? Inspect Process Niceness Levels
Quickly find and interpret process "nice" values, then adjust priorities safely on a Linux host.
Monitor System Interrupts and Pinpoint IRQ Storms
Learn to watch Linux interrupt counters, spot noisy devices and rebalance IRQs before they throttle your system.
Manual hugepage configuration for performance
Hands-on steps to reserve, mount and use Linux hugepages for low-latency workloads
Inspect HugePages Configuration for Performance
Quickly find how hugepages are configured, why they matter, and how to read the kernel state.
Inspect process memory maps with cat proc maps
Peek into a program's address space by reading the kernel's /proc maps file and learn to interpret what you see.
Check CPU Thermal Info Quickly
Learn how to read CPU temperatures on Linux and act before heat becomes a problem.
Quiet the Kernel: Blacklist Modules
Learn how to stop unwanted kernel modules from loading, with hands-on commands and persistent configuration.
Load kernel-module dependencies with modprobe
Let the system pull required kernel modules and their dependencies automatically.
Explore kernel modules with lsmod
Quickly inspect which kernel modules are loaded and why they matter for systems and troubleshooting.
Make the Kernel Listen: Configure SysRq Options
Enable, restrict and persist the kernel's magic SysRq so a stuck system can be steered from keyboard or scripts.
Control Logical Console Sessions
Manage virtual terminals, switch sessions, and inspect who is logged in on Linux.
Map Files to Block Devices with Loopback
Turn a regular file into a block device to mount, format or encrypt it and learn exact commands to do it safely.
Measure Filesystem Speed with fio
Run quick, repeatable IO benchmarks to quantify filesystem performance with fio and learn how to interpret the results.
Find file magic types with file
Identify files by their magic numbers using the file command.
Extract compressed tar.xz archives
Quickly inspect and extract .tar.xz archives using tar and xz tools, safely and efficiently.
Create encrypted tar archives
Keep archives compact and confidential by combining tar with modern encryption tools for safe transport and storage.
Spot and Inspect Mounted tmpfs Quickly
Find which tmpfs instances are active, inspect their options and size, and act on them from the shell.
Lockout Policies with pam_faillock
Harden login security by automatically locking accounts after repeated authentication failures.
Harden passwords with PAM policies
Configure PAM to enforce strong, system-wide password rules and reject weak credentials at the point of change.
Test PAM authentication flow in detail
Practice triggering and tracing PAM authentication decisions to find failures fast.
Inspect PAM configuration files to verify Linux authentication
Learn to read, test and reason about the files under /etc/pam.d so you can diagnose authentication behavior quickly.
Set and Change Linux Account Expiration
Learn to set, change and remove account expiry dates from the command line to control temporary access quickly.
Inspect Login Failures with faillog
Quickly spot and manage failed login attempts using the faillog utility to detect locked accounts and brute-force activity.
Terminate user sessions safely
Learn how to notify users, send polite signals, and escalate to forced termination without risking data loss.
Track Active User Sessions on Linux
Quickly discover who is logged in, from where, and what they are doing using simple command-line tools.
Archive and compress with tar
Create, inspect and extract compressed archives quickly on the command line.
Mastering chmod: control file permissions
Learn how to change Unix file and directory permissions quickly and safely with practical commands.
Create and verify an MD5 checksum
Quickly produce and check MD5 checksums on the command line to verify file integrity.
Rotate SSH Keys Regularly
Practical steps to generate, deploy and remove SSH keys so access stays secure and manageable.
Analyze Login Failures: Track, Diagnose, Fix
Hands-on steps to find why users cannot authenticate and how to act.
Generate SSH fingerprints for verification
Quickly produce and verify SSH key fingerprints to ensure host authenticity and key integrity.
Tame default file permissions: set a user-specific umask
Control default file permissions per user to protect data and workflows.
Inspect system default umask
Quickly discover the mask that shapes new file and directory permissions.
Test IPv6 Connectivity Quickly
Hands-on commands to verify and troubleshoot IPv6 reachability from the shell.
Temporarily Disable IPv6 for Troubleshooting
Quick, reversible steps to turn off IPv6 at runtime for diagnostics and compatibility checks.
Enable IPv6 Networking on Linux
Turn on IPv6, verify addressing, and configure kernel and network tools so your Linux host speaks the modern Internet protocol.
Probe TCP ports with telnet
Use telnet as a quick raw TCP probe to verify service reachability and exchange minimal protocol data.
Check user shell restrictions
Quickly discover which login shells a user has and whether those shells impose restrictions.
Spotting Zombies in the Process Table
Find defunct processes fast and learn how to make the parent reap them.
Catch orphaned processes fast
Spot processes adopted by PID 1 and reclaim control of stray jobs quickly.
Tuning tmpfs Mount Options for Performance and Safety
Practical steps to mount tmpfs with the right options to balance speed and security.
Hunt Authentication Events
Locate and interpret authentication entries in system logs to spot failed logins and suspicious access.
See process limits with ulimit -a
Quickly list and inspect shell resource limits to troubleshoot and tune processes.
Global bashrc: Make system-wide shell tweaks
Edit the systemwide bash startup file to set aliases, environment and behavior for every interactive shell.
Configure environment using /etc/profile
Set system-wide environment variables for all login shells with a single file.
Fast Calculations with bc on Linux
Do quick, accurate arithmetic directly in the terminal with the bc calculator.
Refresh the dynamic linker cache with ldconfig
Make newly installed shared libraries visible to the runtime linker without rebooting.
Where does Linux look for libraries?
Use ldconfig to inspect and refresh the shared library search paths that the dynamic linker uses.
Trace libraries with ldd
Quickly reveal which shared libraries a program needs and find missing dependencies before they stop you.
Catch Every Call: Monitor System Calls with strace
Trace what a program asks the kernel to do and find bugs, permission problems or surprises.
Limit user processes with ulimit
Prevent a single account from spawning runaway processes with a quick shell limit.
Named Pipes: Connect Processes Without Files
Create a FIFO with `mkfifo` and let processes exchange data through a filesystem entry.
Measure text quickly with wc
Use the wc command to count words, lines, bytes and characters on the command line and get fast file statistics.
Repeat Commands Efficiently with seq
Use the simple `seq` generator to run commands repeatedly without writing long loops.
Measure command time using time
Quickly measure how long a command runs and interpret real, user and sys times.
Join text files by columns with paste
Quickly combine columns from multiple text files on the command line and reshape data with simple options.
Split Large Files Quickly
Learn to slice big files into manageable parts using the split command
Combine find and xargs to act on many files
Efficiently build file lists with find and execute commands in bulk with xargs.
Hunt Text Fast with grep
Search text inside files quickly from the command line and turn patterns into action.
Hunt the big culprits
Fast command-line recipes to locate the files that steal your disk space.
Inspect Active Mount Options
Quickly discover which mount options are currently active on a system and why they matter.
Mount ISO images loopback access
Access ISO files like normal filesystems without burning media.
Fix a Broken Bootloader by Hand
Hands-on steps to restore GRUB or EFI boot entries using a live system and minimal tools.
Measure disk speed with dd simply
Hands-on raw disk I/O measurements with the dd tool to get a quick view of write and read performance.
Name Your Disks With Filesystem Labels
A practical guide to set and use filesystem labels so volumes are easy to identify and mount.
Find and Verify Block Device UUIDs for Reliable Mounting
Quickly locate the UUIDs that tie disks to mounts and make system boots predictable.
Battery status at a glance
Quick, practical ways to read laptop battery status from the Linux command line.
Inspect hardware with dmidecode
Read the system’s DMI/SMBIOS tables to discover hardware details quickly.
Automate Jobs with systemd Timers
Swap cron for systemd timers to schedule tasks with tighter integration, logging and dependency control.
Spot timer drift and scheduling glitches
Inspect system timers, verify clock sources and measure drift to troubleshoot missed or delayed jobs.
Canceling at Jobs Safely
Learn how to list and remove scheduled at jobs from the command line.
See Scheduled at Jobs Quickly
Inspect and manage one-time "at" scheduled jobs from the shell.
One-time jobs with at
Schedule single-run commands fast from the shell.
Check cron schedule formatting quickly
Validate and preview cron timing with quick CLI checks and a tiny parser to avoid scheduling surprises.
Rotate Custom Log Files
Keep growing log files in check by rotating, compressing and pruning them automatically.
Tame logs with rsyslog filters
Learn to route, drop, and rewrite messages with rsyslog filters for clearer log management.
Inspect System Logs with rsyslog: Quick Checks and Troubleshooting
Practical commands and checks to read, test and troubleshoot the logs rsyslog writes.
Refresh GRUB2 Configuration Safely
Change boot settings, kernel options or timeout and then regenerate GRUB2 configuration safely.
Control GRUB Boot Timeout for Faster Starts
Learn how to set and regenerate GRUB timeout so machines boot predictably and quickly.
Check Bootloader Configuration Files Quickly
Learn how to locate and verify bootloader settings so the correct kernel and options are used at boot.
Modify initramfs configuration
Practical steps to edit and regenerate the Linux initramfs for boots, encryption and rescue scenarios.
Rebuild initramfs images: fix boot and add drivers
Recreate the early userspace image to recover boots and include new drivers quickly.
Inspect kernel command line
Quickly read what the kernel received at boot and diagnose boot issues.
Reveal CPU Frequency Scaling
Quickly inspect current CPU frequencies, governors and scaling behavior from the command line.
Trace the Process Tree with pstree
Quickly visualise parent-child relationships of running processes with pstree.
Watch Your Commands in Real Time
Use the watch utility to rerun and observe command output so he can spot changes live.
Configure Default Gateway in Linux
Hands-on steps to set, verify and persist the default route so outbound traffic reaches the right gateway.
Clear ARP Cache Manually
Remove stale Ethernet-to-IP mappings to restore connectivity or test neighbor discovery.
Inspect ARP Cache: See Who Lives at That IP
Quickly inspect and manage the ARP cache to diagnose local network reachability and identify MAC addresses.
Query Routing Table with route
Quickly inspect and understand the kernel routing table using the classic Linux `route` command.
Make Hostnames Stick: Persistent Local Resolution
Bind names to IPs so hostnames resolve reliably across boots and network changes.
Measure network latency with mtr
Quickly locate latency and packet loss along a route using a single interactive command-line tool.
Probe Network Connections with ss
Learn to inspect sockets and verify connectivity quickly using the `ss` utility on Linux.
Secure Package Repos with GPG Keys
Keep package sources authentic by configuring repository GPG keys and signing verification for apt repositories.
Convert RPMs to DEBs with alien
Quickly turn foreign binary packages into Debian-format packages to test or install them on Debian-based systems.
Extract RPM Contents Quickly
Learn to inspect and extract files from RPM packages without installing them.
Find installed RPM packages quickly
Learn to inspect installed RPM packages with practical commands and examples.
Hold or Prefer: Pin Packages with apt preferences
Choose which repository or version apt should prefer and stop unwanted upgrades or downgrades.
Inspect Package Dependencies
Learn how to reveal what a package needs before you install it and avoid surprises.
Update Package Lists: See What You Can Install
Refresh the system's view of available packages so installations and upgrades know what is current.
Make Your Hostname Stick Across Reboots
Set a persistent system name so the machine keeps a stable identity across boots and services.
Find who is listening on your Linux host
Quickly locate listening sockets and the processes that own them to troubleshoot services and ports.
Inspect system entropy with cat random
Run a few simple cat commands to observe kernel entropy, blocking behavior and where randomness comes from.
Analyze filesystem usage deeply with ncdu
Find the folders that eat your disk with a fast, interactive terminal browser.
Uptime and Load: Read Your System's Pulse
Quickly check how long a Linux host has been running and how busy it is.
Kill by name with pkill
Quickly find and stop processes by name using the pkill command.
Check running shells with ps
Quickly find which shell processes are running on a Linux host and inspect how they were started.
Manage Console Keymaps for Linux Consoles
Quickly change and persist virtual-console keyboard mappings.
Reliable temporary files with mktemp
Create unique, race-free temporary files and directories for scripts and tools.
Tame Your PATH in bashrc
Edit your bashrc to add, reorder or fix the PATH so personal tools run without typing full paths.
Peek Into Your Shell Environment
See which environment variables your shell exports and how they influence processes.
Track leaking memory with pmap
Use the simple `pmap` snapshot to spot which memory segments grow and find leaks fast.
Watch Live File Changes with tail -f
See appended log lines instantly from the shell and debug in real time.
List installed shells on this system
Quick methods to discover which shells are present and which shells users actually have assigned.
Change a User's Default Shell Quickly
Switch a user's login shell safely and immediately, with commands and checks you can run right now.
Create Custom Locales with localedef
Hands-on steps to compile, enable and manage locale definitions on Linux using localedef and locale-gen.
Inspect system locale configuration
Quick checks and fixes to ensure the system uses the correct language and character encoding.
See and Save Output with tee
Display a command's output on the screen while saving it to a file, and learn practical tricks to split streams.
Craft a Smart Bash Prompt with PS1
Learn how to shape the bash prompt so it becomes a practical source of context and reduces mistakes.
Clear Shell History Securely
Practical steps to remove command history from your shell while understanding the limits of secure deletion.
Explore Your Shell History with history
See, recall and reuse past commands quickly with the shell builtin history.
Who's on the System Right Now?
Quickly discover who is logged in and what he is doing, using small, reliable commands.
Monitor network bandwidth with iftop
See which connections use your bandwidth in real time with a compact, command-line viewer.
Resize Filesystems Safely
Learn how to grow and shrink filesystems without losing data and how to avoid common pitfalls.
Relabeling Filesystems Fast
Change or convert filesystem labels safely across ext4, xfs, btrfs, vfat and ntfs using concrete commands.
Analyze Partition Table with parted
Use parted to inspect disk labels, partitions and free space quickly and safely.
Create a Swap File Manually
Hands-on shell recipe to add swap space quickly and safely on a Linux host.
Enable swap partition and add memory fast
Turn a spare partition into usable swap in minutes and avoid out-of-memory troubles.
Check Free Inodes on a Linux Disk
Quickly discover whether the filesystem is out of inodes and how to act before services fail.
Setcap: Give Programs Capabilities Without Root
Grant specific kernel privileges to binaries so they can do one job without running as root.
Inspect file capabilities with getcap
Quickly discover which POSIX capabilities a binary carries and why that matters for system security.
Tweak SELinux Behavior with Booleans
Quickly change how SELinux treats services without rewriting policies.
Temporarily Set SELinux Permissive for Troubleshooting
Switch SELinux into permissive mode briefly to observe denials without blocking execution and speed up troubleshooting.
Inspect SELinux contexts
Quickly see which SELinux contexts files, processes and users carry and decide what to do next.
Know Where Linux Stores Everything
Map the root, learn where services, logs and users live, and gain confidence navigating any Linux host.
Master Local Hostname Resolution
Control name-to-IP mapping on a single Linux host quickly and predictably.
Check running timers with systemd
Quickly inspect active and scheduled systemd timers from the command line and act on them.
View immutable file attributes
Quickly check whether a file is locked against modification using `lsattr` and related tools.
Make files immutable with chattr
Use low-level filesystem attributes to prevent modifications and deletions with a single command.
Control cron email notifications
Decide who receives cron output by configuring MAILTO, silencing noisy jobs, or wiring cron to an MTA.
Inspect cron logs to trace scheduled tasks
Learn where cron writes its messages and how to extract the lines that tell you what ran and why.
Control logrotate frequency for reliable logs
Practical steps to change when and how logrotate rotates your log files.
Inspect Rotated Logs and Compressed Archives
Practical ways to read rotated and compressed log files without breaking rotation.
Force systemd to flush its journal
Push in-memory journal entries to persistent storage with a quick journalctl command.
Tame systemd journal growth
Quickly inspect and control how much disk space the systemd journal consumes, and reclaim space without breaking logging.
Run Commands at Startup with rc.local
A hands-on guide to make scripts run at boot, even on systemd systems.
Keep Servers Updated Automatically
Set up safe, unattended package updates so systems stay secure with minimal hands-on time.
Switch runlevels with systemctl isolate
Use systemd's isolate to jump the system into another target quickly and safely.
Send system-wide alerts with wall
Quickly broadcast text messages to every logged-in terminal to announce maintenance or urgent notices.
Schedule system shutdowns safely
Plan and run timed halts and reboots from the command line with practical examples and safety tips.
Ship archives safely to remote hosts
Create, encrypt and transfer archives over SSH with practical, secure commands.
Zip archives on Linux: compress, bundle, ship
Learn how to create and manage compressed zip archives from the command line.
Shrink files fast with gzip
Learn how to compress and decompress files quickly on the command line using gzip.
Make quick backups with tar
Archive, compress and restore files with a single, reliable command.
Stop Bad Traffic: Block IP Ranges with iptables
Quick, practical steps to deny traffic from malicious IP ranges using iptables.
Save and restore iptables rules
Practical steps to persist and recover firewall rules using iptables-save and iptables-restore.
Lock down a Linux server with iptables
A hands-on guide to write and apply basic iptables firewall rules that protect SSH and web services.
Enable IP Forwarding and Route Traffic
Turn a Linux host into a simple router by enabling kernel IP forwarding and try the commands yourself.
Customize the MOTD login banner
Turn the MOTD into a helpful, secure and dynamic login message.
Locking Down SSH: Practical Steps to Reduce Risk
Concrete actions and commands to make SSH access resilient against common attacks.
Restrict SSH by User: Lock Down Remote Logins
Allow or deny SSH logins per account using sshd configuration and related controls.
Create SSH Key Pairs for Secure Logins
Generate, install and manage SSH key pairs to replace passwords for safer remote access.
Securely copy files with scp
Learn how to quickly and securely transfer files between machines using scp, the SSH-based copy tool.
Probe and Debug Ports with nc
Practical steps to probe ports and debug services using nc.
Query DNS Records with host
Inspect DNS records, reverse lookups and server-specific queries with the host command.
Quick DNS Checks with dig
Run a few `dig` commands to verify name resolution, understand answers, and find where things break.
Take Control: Modify Routing Tables to Redirect Traffic
Learn to read and change Linux routing tables to steer packets where you need them.
Assign temporary IP addresses on Linux
Quickly add a runtime IP to an interface for testing, maintenance or one-off services.
Restart network services to restore connectivity
Hands-on steps to bring interfaces and daemons back without guesswork.
See What Connections Your Linux System Is Making
List and inspect active TCP, UDP and UNIX sockets from the command line to troubleshoot and secure a Linux host.
Catch I/O Hogs with iotop
See which processes are reading and writing the disk right now and hunt down bottlenecks.
Inspect CPU details with lscpu
Quickly inspect processor topology and capabilities from the command line using a single utility.
Inspect block I/O with iostat
Quickly spot which disks are busy and measure request rates and latencies.
Inspect PCI Devices with lspci
Read hardware IDs, find drivers and debug PCI devices from the shell.
Make sysctl settings survive reboots
Apply kernel parameter tweaks now and make them persistent across boots using the right files and commands.
Tame Kernel Settings with sysctl for Safer Systems
Apply Linux kernel tunables at runtime for performance or security with practical examples
Speeding Up Boot With systemd-analyze
Inspect where time is spent during boot and act on concrete slow services.
Find Running Daemons Quickly
Practical, command-line ways to list and inspect the daemons running on a Linux host.
Inspect host uptime
Quick, practical commands to find how long a Linux host has been running and what the numbers mean.
Check failed units with systemctl
Find failed systemd units fast and fix services with concrete commands.
Create custom systemd service
Turn a script or program into a managed service that starts at boot and restarts on failure.
Enable services at boot with systemd
Make chosen services start automatically at boot by enabling their unit files with systemctl.
Configure systemd units: manage services the right way
Learn to write, enable and troubleshoot systemd unit files so services behave predictably during boot and runtime.
Peek into the Kernel Ring Buffer
Quickly inspect recent kernel messages to diagnose hardware and boot-time issues.
Lock and unlock user accounts quickly
Practical, command-line ways to disable and re-enable Linux accounts for maintenance and security.
When Did the System Boot Last?
Quick commands to find the last system boot time and why it matters.
Manage user sessions with who
Quickly see who is logged in, where from, and how long sessions have been idle.
Configure system limits in limits.conf
Enforce per-user resource caps at login to prevent resource exhaustion and keep systems stable.
Set password policies with chage
Enforce password aging, warnings and account expiry using the chage command.
Track Who Logged In: last & lastlog
Quickly list successful and failed user logins to investigate access patterns and spot anomalies.
Hard Links: Share a File Without Copying
Create a second filename that points to the identical file data on disk without duplicating bytes.
Inspect File Metadata with stat
Quickly reveal inode details, timestamps and permissions for any file using the stat utility.
Peek and Tail: Read Logs Fast
Small commands, big time savings when inspecting files.
Patch files with patch: apply diffs fast
Learn to create and apply diff patches on the command line to update files reliably.
Spot differences with diff
Quickly find and understand file differences from the shell.
Alphabetize text files fast with sort
Learn to sort lines alphabetically using the GNU sort command and related tools.
Transform text with awk
Practical text reshaping and data extraction at the shell prompt using awk.
Edit Files In Place With sed
Use sed to apply quick, repeatable edits directly to files from the shell.
Slice columns fast with cut
Practical, hands-on tips to extract fields and fixed-width columns quickly with the cut command.
Trace sudo activity and find misuse
Quick, practical steps to extract, parse and investigate sudo events from syslog and the systemd journal.
Quick Bash Aliases That Speed Up Your Shell
Create persistent, safe aliases to shorten commands and speed up your shell workflow.
Temporarily Modify PATH for Quick Tests
Quickly change your PATH for a session or a single command to test tools without permanent edits.
Inspect environment with env
Quickly list and control the process environment to debug scripts and run programs with tailored variables.
Trace Service Dependencies to Fix Startup Failures
Learn to map what a service needs and what needs it using systemctl and a few inspection tricks.
Manage Debian Packages with dpkg: Inspect, Install, Remove
Learn practical, low-level package control to inspect, install, and remove .deb files directly on Debian-based systems.
Repairing the RPM database
How to detect and rebuild a corrupt RPM database quickly and safely from the command line.
Install Local RPM Files: Offline Package Management
Learn to install and verify RPM packages from local files, handle dependencies, and choose the right tool for the job.
Download packages with yumdownloader
Fetch RPMs from configured repositories without installing them, useful for offline systems and audits.
Spot and Inspect Packages with apt-cache
Search package metadata locally and inspect details with the apt-cache tool to find the right Debian/Ubuntu package quickly.
View kernel version with uname -r
Quickly discover the running Linux kernel release with a single command.
Kill Processes: Stop runaway tasks safely
Identify hung or runaway Linux processes and terminate them reliably using the kill command and signals.
Control Background Jobs with bg and fg
Quickly move tasks between background and foreground to stay productive on the command line.
Persistent mounts with fstab
Make devices and network shares mount automatically and reliably at boot.
Check inode usage on filesystem
Discover when a filesystem has run out of inodes and how to diagnose it quickly with common command line tools.
Explore block devices with lsblk
Quickly inspect disks, partitions and mounts with a single, glanceable command.
Limit process resources with ulimit
Keep runaway programs in check by restricting what a shell and its child processes may consume.
Quick SELinux Check: Mode and Status
Fast, practical commands to read SELinux mode and full status so you can act with confidence.
Tame temporary files with tmpfiles.d
Use systemd's tmpfiles.d fragments to create, protect and clean transient files reliably across boots.
Meet Your Kernel and System
Use the uname command to reveal kernel, machine and OS bits in seconds.
Repair filesystems using fsck
Practical steps to check and repair Linux filesystems safely with fsck.
Backup MBR with dd: Capture the boot sector
Create a byte-perfect backup of the first 512 bytes so you can restore a damaged boot sector quickly.
Autofs: Automount on Demand
Configure autofs to mount file systems on access and free resources when idle.
Spot system bottlenecks with vmstat
Use a tiny, built-in tool to reveal CPU, memory and I/O pressure quickly.
Inspect open ports with netstat
Quickly identify listening services and active connections to diagnose and secure a Linux host.
Manage network interfaces with nmcli
Control NetworkManager connections from the shell to script, debug and automate interface tasks.
Archive Logs Cleanly with logrotate
Learn how to keep log directories tidy by rotating, compressing and archiving logs with logrotate.
Rsync: Fast, reliable file synchronization
Keep folders identical and efficient by sending only differences with rsync.
Grant sudo privileges securely
Learn how to grant, restrict and audit sudo rights so users can perform administrative tasks without exposing the whole system.
Master running tasks with htop
Explore and control live system processes with a fast interactive viewer.
Practical Firewall Rules with UFW
Learn a compact, hands-on approach to harden a Linux host using the Uncomplicated Firewall.
Check service status with systemctl status
Quickly inspect whether a daemon runs and find the reason when it does not.
vi Basics: Edit Faster at the Shell
Learn how to open, edit and save files with vi and speed up command-line text work.
Persist Environment Variables in Linux
Learn how to set environment variables so they survive logins and reboots.
Manage SSH server and keys for secure access
Hands-on steps to run, harden and maintain an SSH server and its keys.
Manual IPv4: Assign and Verify a Static Address
Learn to set a static IPv4 address, verify connectivity, and make the change persistent on a Linux system.
Find Anything Fast: Master the find Command
Locate files precisely and act on them from the shell, fast and reliably.
Monitor memory usage with free
Inspect RAM and swap quickly with the free command to spot memory bottlenecks in seconds.
Configure NTP time synchronization on Linux
Keep system clocks precise across servers and desktops by configuring reliable NTP synchronization.
Investigate boot problems with dmesg
Read the kernel's own boot diary to find hardware and driver issues fast.
Reset forgotten root password from single-user mode
Practical, step-by-step recovery of root access by booting into single-user mode.
Set default runlevel with systemd
Change the default systemd target that corresponds to classic runlevels and control default boot behavior.
Link Mastery: Create and Manage Symbolic Links
Learn how to create, inspect and safely update symbolic links to manage files and deployments.
Manage printers with CUPS tools
Practical, command-line and web-driven workflows for installing, inspecting and controlling printers with CUPS.
Trust files with sha256sum
Learn to compute and verify SHA-256 checksums from the command line to ensure file integrity.
Load and Unload Kernel Modules: Live Control of the Linux Kernel
Hands-on control of kernel drivers and features using modprobe, insmod and friends to shape a running system.
Inspect Running Kernel Modules: Find, Query, and Manage
Practical commands to list, inspect and manage loaded kernel modules on a running system.
Take Control of Routing with ip route
Add, inspect and remove static routes from the shell to steer Linux traffic exactly where you need it.
Follow the Path with traceroute
Probe each hop between you and a destination to find where packets slow or stop.
Inspect PCI and USB Hardware with lspci and lsusb
Quick, hands-on inspection of connected PCI and USB devices and their drivers.
Mastering Linux Software Repositories: Add, Verify, Update
Learn to add, trust and control package sources so installations stay reliable and secure.
Harnessing Pipes and Redirects for Cleaner Output
Learn to steer command output and errors into files, other programs, or combined streams to build reliable shell pipelines.
Find lines in seconds
Harness the speed of grep to filter command output and files with precision.
System Locale and Timezone: Set It Right
Practical steps to configure system locale and timezone with systemd and common tools.
Manage system services with service command
Control start stop and status of traditional init services quickly from the shell.
Tune GRUB bootloader settings
Change timeout, kernel flags and defaults to control how Linux boots.
Troubleshoot network with ip and ping
Quick, pragmatic steps to find and fix common network faults using the ip suite and ping.
Configure swap space manually
Learn to create and manage swap files and partitions from the shell to control memory pressure and system behavior.
Tar archive: create and extract
Learn to pack and unpack files with tar on the command line and move archives around efficiently.
Master POSIX ACLs with setfacl
Apply precise per-user and per-group file permissions using setfacl for flexible access control.
Manage system logs using journalctl
Use journalctl to read, filter and follow the systemd journal and find answers in logs quickly.
Watch Processes Live with ps and top
Learn to snapshot processes with ps and inspect live activity with top to find and fix resource hogs.
Automate Tasks with cron Jobs
Schedule scripts and maintenance jobs reliably using the cron daemon and crontab.
Configure hostname and DNS the right way
Practical steps to name your machine and make name resolution reliable on modern Linux systems.
Inspect disk usage with du and df
Find what fills disks: `df` shows filesystem capacity, `du` exposes directory usage.
Manage groups with groupadd and groupdel
Create and remove Unix groups from the shell to shape access and permission boundaries.
Control Services with systemctl
Learn to start, stop, enable and inspect systemd services from the command line.
Install Software Reliably with Package Managers
Master command-line package managers to install, update and remove software reliably on Linux.
Hands-on: Configure a Network Interface by Hand
Learn to bring up an interface, assign an address and make the configuration persistent using real commands.
Inspect /var/log for System Clues
Learn how to read and act on the files under /var/log to diagnose Linux problems quickly.
Mount and Unmount Filesystems: Attach Storage Cleanly
Learn how to attach and detach filesystems safely from the command line.
Format filesystems with mkfs
Quickly create filesystems on block devices using the mkfs family of tools.
Create Partitions with fdisk: Fast, Precise Disk Layouts
Hands-on steps to plan and create partitions with fdisk and get disks ready for filesystems or OS installs
Control File Access with chmod
Change file and directory permissions quickly using octal or symbolic notation.
Change file ownership with chown
Master the chown command to assign files to the right user and group quickly.
Manage users and set passwords: hands-on
Create, control and secure accounts from the shell with practical commands.
Mount a CD-ROM quickly and safely
Hands-on steps to detect, mount and unmount a physical CD or an ISO image from the command line.
Who runs what: mastering ps to inspect processes
Learn how to locate, filter and understand running processes with the ps command to diagnose issues fast.
ls -la: See Every File and Its Details
List all files, including hidden ones, and inspect permissions, sizes and timestamps with a single command.
Explore files quickly with ls
Master `ls` to inspect directories fast and confidently.
Find files in seconds with locate
Discover how the locate command finds files lightning-fast using a searchable database.
Find: Locate Anything on Linux Fast
Master the `find` command to locate, filter and act on files across a filesystem — fast and safely.
