Skip to main content
Mapagam

58 SECTIONS · 1664 TOPICS

Linux Roadmap

  1. Understanding Linux System Architecture

    1. 1. Understanding Kernel vs User Space
    2. Example: System Call Flow
    3. 2. Understanding Linux File System Hierarchy
    4. Example: View file system hierarchy
    5. 3. Understanding System Processes
    6. Example: Process Management
    7. Process Lifecycle
    8. 4. Understanding Runlevels and Targets
    9. Example: Changing Runlevel
    10. Runlevel vs Target Mapping
    11. 5. Understanding Linux Boot Sequence
    12. Example: GRUB Configuration
    13. 6. Understanding Shell Types
    14. Example: Checking Current Shell
    15. Example: Switching Shells
    16. 7. Viewing System Information
    17. Example: Check system uptime and load average
    18. Example: View detailed system information
    19. Example: Display disk usage
    20. 8. Checking Distribution Version
    21. 9. Viewing Kernel Version
    22. Example: Check kernel version
    23. 10. Viewing System Uptime and Load Average
    24. Example: Using uptime command

  2. Navigating the File System

    1. 1. Understanding Absolute vs Relative Paths
    2. Example: Using Absolute vs Relative Paths
    3. 2. Navigating Directories
    4. Example: Changing to a subdirectory
    5. 3. Displaying Current Directory
    6. Example: Using pwd command
    7. 4. Listing Directory Contents
    8. 5. Using Directory Stack
    9. Example: Managing Directory Stack
    10. 6. Viewing File Type
    11. Example: Using file command
    12. 7. Following Symbolic Links
    13. Example: Using readlink to resolve a symlink
    14. Example: Using realpath to get the absolute path of a symlink
    15. 8. Understanding Hidden Files
    16. Example: Listing Hidden Files
    17. Example: Creating a Hidden File
    18. 9. Using Tab Completion
    19. Example: Basic tab completion
    20. 10. Using Wildcards
    21. Example: Using wildcards to copy files
    22. Example: Using wildcards to list files recursively

  3. Working with Files and Directories

    1. 1. Creating Files
    2. Example: Creating a new file with content
    3. Example: Using touch to create an empty file
    4. 2. Creating Directories
    5. 3. Copying Files and Directories
    6. Example: Copying a file with preserved attributes
    7. Example: Recursively copying a directory
    8. 4. Moving and Renaming
    9. 5. Removing Files and Directories
    10. Example: Remove a file
    11. Example: Remove a directory and its contents
    12. Example: Force remove a file with no confirmation
    13. Key Points
    14. 6. Creating Symbolic Links
    15. Example: Creating a symbolic link to a directory
    16. Example: Creating a symbolic link to a file
    17. 7. Creating Hard Links
    18. Example: Creating a Hard Link
    19. Key Points About Hard Links
    20. 8. Displaying File Contents
    21. Example: Using cat to view file contents
    22. Example: Using head to view first lines of a file
    23. Example: Using tail to follow log file changes
    24. 9. Following File Updates
    25. Example: Watching Log File Changes
    26. Example: Using inotifywait for File Changes
    27. 10. Counting Lines, Words, Characters
    28. Example: Using wc command
    29. Example: Counting lines only
    30. 11. Comparing Files
    31. Example: Using diff to compare files
    32. Example: Using cmp to compare files byte by byte
    33. 12. Finding File Differences
    34. Example: Comparing Files with Unified Output
    35. Key Points

  4. Working with Text Editors

    1. 1. Using nano Editor
    2. Example: Editing a Configuration File
    3. 2. Using vim Editor
    4. Example: Basic vim workflow
    5. Example: Search and replace in vim
    6. 3. Understanding vim Modes
    7. Example: Switching Between Modes
    8. 4. Navigating in vim
    9. Example: Moving to line 10
    10. Example: Moving to column 5
    11. Example: Moving to next word
    12. 5. Editing in vim
    13. Example: Basic vim workflow
    14. Example: Search and replace in vim
    15. Example: Setting up vim for Python development
    16. 6. Searching and Replacing in vim
    17. Example: Replace all occurrences of a word
    18. Example: Replace with confirmation
    19. 7. Using vim Visual Mode
    20. Example: Selecting text in visual mode
    21. Example: Using visual mode to change text
    22. Workflow: Using visual mode to change text
    23. 8. Configuring vim
    24. Example: Basic vimrc configuration
    25. 9. Using Multiple Buffers in vim
    26. Example: Managing Multiple Buffers
    27. 10. Using emacs Editor
    28. Example: Basic Emacs Workflow

  5. Managing File Permissions and Ownership

    1. 1. Understanding Permission Model
    2. Example: Permission Representation
    3. 2. Viewing Permissions
    4. 3. Changing Permissions with Symbolic Mode
    5. Example: Adding Read Permission to Owner
    6. 4. Changing Permissions with Octal Mode
    7. Example: Setting Permissions to 755
    8. 5. Changing Ownership
    9. Example: Changing Ownership to Root
    10. 6. Changing Group Ownership
    11. Example: Changing Group Ownership
    12. 7. Setting Default Permissions
    13. Setting umask
    14. Example: Setting umask to 077
    15. 8. Applying Permissions Recursively
    16. Example: Recursive Permission Change
    17. 9. Setting Special Permissions
    18. Example: Setting SUID on passwd
    19. 10. Using Access Control Lists
    20. Example: Adding User to ACL
    21. 11. Understanding File Attributes
    22. Example: Setting Immutable Attribute

  6. Understanding Inodes and File System Internals

    1. 1. Understanding Inode Structure
    2. Example: Inspecting Inode Details
    3. 2. Viewing Inode Information
    4. Example: Using stat to view inode details
    5. 3. Checking Inode Usage
    6. Example: Find files using a specific inode number
    7. 4. Understanding Hard Links vs Inodes
    8. Example: Creating and Using Hard Links
    9. 5. Finding Files by Inode Number
    10. Example: Find file by inode number in a directory
    11. 6. Understanding File Descriptors
    12. Example: Opening a File Descriptor
    13. Example: Redirecting File Descriptors
    14. 7. Viewing Open File Descriptors
    15. Example: Using lsof to view open files
    16. Example: Inspecting file descriptors in /proc
    17. 8. Understanding Sparse Files
    18. Example: Creating a Sparse File
    19. Example: Checking File Size and Disk Usage
    20. Key Points About Sparse Files
    21. 9. Managing Extended Attributes
    22. Example: Setting and Retrieving Extended Attributes
    23. 10. Understanding File System Journaling
    24. Example: Enabling Journaling on ext4
    25. Key Points About Journaling

  7. Searching and Finding Files

    1. 1. Finding Files by Name
    2. Example: Find files with a specific extension
    3. Example: Find files with a specific name pattern
    4. 2. Finding by Type
    5. Example: Find all .txt files in the home directory
    6. Example: Find all directories named "backup"
    7. 3. Finding by Size
    8. Example: Find files larger than 50MB
    9. Example: Find files smaller than 1KB
    10. Example: Find files exactly 100MB
    11. 4. Finding by Modification Time
    12. Example: Find files modified in the last 24 hours
    13. Example: Find files modified more than 7 days ago
    14. Example: Find files modified exactly 5 minutes ago
    15. 5. Finding by Permissions
    16. Example: Find files with read permission for owner
    17. Example: Find files with execute permission for group
    18. Example: Find directories with no write permission for others
    19. 6. Executing Commands on Results
    20. Example: Execute command on all .txt files
    21. Example: Rename all .log files to .old
    22. 7. Using locate Command
    23. Example: Find all files named 'config.json'
    24. Example: Case-insensitive search for 'readme'
    25. 8. Finding Executables with which
    26. Example: Finding executable location
    27. Example: Using
    28. 9. Finding Files with whereis
    29. Example: Find all files related to 'ls'
    30. Summary of whereis Options
    31. 10. Searching File Contents
    32. Example: Using grep to find lines matching a pattern
    33. Example: Using ripgrep to search recursively in a directory
    34. 11. Combining Find Conditions
    35. Example: Complex Find with Multiple Conditions

  8. Processing Text with grep

    1. 1. Searching with Basic Patterns
    2. Example: Basic Pattern Search
    3. Example: Start of Line Match
    4. 2. Case-Insensitive Search
    5. Example: Case-Insensitive Search
    6. 3. Recursive Search
    7. Example: Recursive search in a directory
    8. Example: Recursive search with file type filter
    9. 4. Showing Line Numbers
    10. Example: Display line numbers for matches
    11. 5. Counting Matches
    12. Example: Counting Matches in a File
    13. Example: Counting Non-Matching Lines
    14. 6. Inverting Match
    15. Example: Inverting Match with grep
    16. 7. Matching Whole Words
    17. Example: Matching whole words
    18. 8. Searching with Context
    19. Example: Show 2 lines before and after each match
    20. Example: Show 3 lines after each match
    21. 9. Using Extended Regex
    22. Example: Matching IP Addresses
    23. Example: Using Groups for Capture
    24. 10. Using Perl-Compatible Regex
    25. Example: Using PCRE to match word boundaries
    26. Example: Using PCRE to match multiline patterns
    27. 11. Listing Only Filenames
    28. Example: Using -l to list filenames
    29. 12. Matching Multiple Patterns

  9. Processing Text with sed

    1. 1. Understanding sed Syntax
    2. Example: Basic substitution
    3. Example: In-place editing
    4. 2. Substituting Text
    5. 3. Editing Files In-Place
    6. Example: In-place replacement with backup
    7. 4. Deleting Lines with Patterns
    8. 5. Inserting Lines
    9. 6. Using Address Ranges
    10. Example: Using Address Ranges to Replace Text in a Range
    11. Example: Using Address Ranges with Regular Expressions
    12. 7. Using Multiple Commands
    13. Example: Chaining sed commands
    14. Workflow: Applying multiple sed commands
    15. 8. Using sed Scripts
    16. Example: Basic sed script to replace text
    17. Example: sed script with multiple commands
    18. 9. Printing Specific Lines
    19. 10. Using Regular Expressions
    20. Example: Matching and Replacing
    21. Example: Using Groups

  10. Processing Text with awk

    1. 1. Understanding awk Syntax
    2. Example: Basic awk usage
    3. Example: Field manipulation
    4. 2. Using Field Separator
    5. Example: Using colon as field separator
    6. 3. Printing Specific Fields
    7. Example: Print specific fields from a CSV file
    8. Example: Print last field of each line
    9. Example: Print fields 2 through 4
    10. 4. Using Patterns
    11. Example: Matching Lines with Regex
    12. Example: Using Field Patterns
    13. 5. Using Built-in Variables
    14. Example: Print line number and field count
    15. Example: Change field separator
    16. 6. Using BEGIN and END Blocks
    17. Example: Initializing Variables with BEGIN
    18. Example: Formatting Output with END
    19. 7. Performing Calculations
    20. Example: Summing Fields in a File
    21. Example: Using Built-in Functions
    22. 8. Using Conditional Statements
    23. Example: Conditional Processing of Fields
    24. 9. Using awk Functions
    25. 10. Formatting Output
    26. Example: Basic Formatting with printf
    27. Example: Floating Point Formatting

  11. Working with Text Manipulation Tools

    1. 1. Sorting Lines
    2. 2. Sorting by Field
    3. Example: Sort by field
    4. Example: Sort numerically by field
    5. 3. Removing Duplicate Lines
    6. Example: Remove duplicate lines from a log file
    7. 4. Cutting Columns
    8. Example: Extracting Fields from a CSV File
    9. Example: Extracting Fields from a Log File
    10. 5. Pasting Files Side by Side
    11. 6. Translating Characters
    12. Example: Translate lowercase vowels to uppercase
    13. Example: Delete specific characters
    14. Example: Complement translation
    15. 7. Joining Files
    16. Example: Using cat to join files
    17. Example: Using paste to merge files side-by-side
    18. Example: Using join to merge files on a common field
    19. 8. Splitting Files
    20. Example: Splitting a Large File into 10MB Chunks
    21. Example: Splitting a Log File into 1000-Line Segments
    22. 9. Reversing Lines
    23. 10. Formatting Text

  12. Working with Regular Expressions

    1. 1. Understanding Basic Regex Syntax
    2. Example: Basic Pattern Matching
    3. Example: Using Character Classes
    4. Example: Quantifier Usage
    5. 2. Using Character Classes
    6. Example: Matching a Date Format
    7. Example: Validating Email Username
    8. 3. Using Quantifiers
    9. Example: Matching phone numbers
    10. Example: Matching repeated words
    11. 4. Using Anchors
    12. Example: Using Anchors in grep
    13. Example: Word Boundary Matching
    14. 5. Using Groups and Capturing
    15. Example: Extracting Date Components
    16. Example: Reformatting Phone Numbers
    17. 6. Using Extended Regex
    18. Example: Using Extended Regex in Grep
    19. Example: Matching Multiple Patterns
    20. Example: Using Quantifiers
    21. 7. Using Perl-Compatible Regex
    22. Example: Matching with PCRE
    23. Example: Using Lookahead
    24. 8. Using Lookahead and Lookbehind
    25. Example: Positive Lookahead for Password Validation
    26. Example: Positive Lookbehind for Currency Parsing
    27. 9. Using Non-Capturing Groups
    28. Example: Using Non-Capturing Groups in Replace Operations
    29. 10. Testing Regex Patterns
    30. Example: Using grep with regex
    31. Example: Using sed to replace matches
    32. Example: Using Lookahead
    33. 8. Using Lookahead and Lookbehind
    34. Example: Positive Lookahead for Password Validation
    35. Example: Positive Lookbehind for Currency Parsing
    36. 9. Using Non-Capturing Groups
    37. Example: Using Non-Capturing Groups in Replace Operations
    38. 10. Testing Regex Patterns
    39. Example: Using grep with regex
    40. Example: Using sed to replace matches
    41. Example: Using sed to replace matches
    42. Example: Using Lookahead
    43. 8. Using Lookahead and Lookbehind
    44. Example: Positive Lookahead for Password Validation
    45. Example: Positive Lookbehind for Currency Parsing
    46. 9. Using Non-Capturing Groups
    47. Example: Using Non-Capturing Groups in Replace Operations
    48. 10. Testing Regex Patterns
    49. Example: Using grep with regex
    50. Example: Using sed to replace matches

  13. Working with Input and Output Redirection

    1. 1. Redirecting Standard Output
    2. Example: Redirecting Output to a File
    3. Example: Appending Output to a Log File
    4. 2. Redirecting Standard Error
    5. Example: Redirecting Errors to a Log File
    6. Example: Merging Standard Output and Error
    7. 3. Redirecting Both Stdout and Stderr
    8. Example: Redirecting both stdout and stderr to a file
    9. Example: Redirecting both streams to /dev/null
    10. 4. Redirecting Input
    11. Example: Using input redirection with sort
    12. Example: Using here document for input
    13. 5. Using Here Documents
    14. Example: Writing a multi-line message to a file
    15. Example: Using here document with a script
    16. 6. Using Here Strings
    17. Example: Using Here Strings with grep
    18. Example: Discarding Both Standard Output and Error
    19. 8. Reading from Files
    20. Example: Reading specific lines from a file
    21. 9. Writing to Files
    22. Example: Overwriting a file with command output
    23. Example: Appending to a log file
    24. 10. Appending to Files
    25. Example: Appending to a Log File

  14. Using Pipes and Command Chaining

    1. 1. Piping Commands
    2. Example: Filtering Log Files
    3. 2. Using tee for Splitting Output
    4. Example: Splitting Output to File and Terminal
    5. Example: Appending to a File with tee
    6. 3. Chaining with AND Operator
    7. Example: Using && to conditionally execute commands
    8. 4. Chaining with OR Operator
    9. Example: Using || to provide a fallback
    10. 5. Running Commands Sequentially
    11. Example: Chaining with && and ||
    12. 6. Using Command Substitution
    13. Example: Using command substitution to get current directory size
    14. Example: Combining command substitution with other commands
    15. 7. Process Substitution
    16. Example: Comparing Directory Contents
    17. Example: Using with
    18. 8. Using xargs for Command Building
    19. Example: Using xargs to process files
    20. Example: Using xargs with -I to rename files
    21. Example: Using xargs with -0 for null-separated input
    22. 9. Parallel Command Execution
    23. Example: Running Multiple Commands in Parallel
    24. Key Points
    25. 10. Grouping Commands
    26. Example: Using braces to group commands

  15. Compressing and Archiving Files

    1. 1. Creating tar Archives
    2. Example: Creating a tar archive
    3. Example: Creating a compressed tar archive
    4. 2. Extracting tar Archives
    5. 3. Listing tar Contents
    6. Example: List contents of a tar archive
    7. Example: List contents excluding log files
    8. 4. Compressing with gzip
    9. Common gzip Options
    10. 5. Compressing with bzip2
    11. Example: Compressing a file with bzip2
    12. Example: Decompressing a file with bunzip2
    13. 6. Compressing with xz
    14. Example: Compressing a file with xz
    15. Example: Compressing with maximum compression
    16. 7. Creating zip Archives
    17. Example: Creating a compressed archive with maximum compression
    18. Example: Creating a zip archive recursively from a directory
    19. 8. Extracting zip Archives
    20. 9. Using 7-Zip
    21. Example: Create a password-protected archive
    22. Example: Create archive with compression level
    23. 10. Compressing with zstd
    24. Example: Compressing a directory with zstd

  16. Managing Environment Variables

    1. 1. Viewing All Variables
    2. Example: Using
    3. Example: Using
    4. 2. Displaying Specific Variable
    5. 3. Setting Temporary Variables
    6. Example: Setting and Using a Temporary Variable
    7. 4. Unsetting Variables
    8. Example: Unsetting a Variable
    9. 5. Setting Permanent Variables
    10. Example: Adding a variable to ~/.bashrc
    11. 6. Setting System-Wide Variables
    12. Example: Adding a system-wide variable
    13. 7. Managing PATH Variable
    14. Example: Adding a Custom Binary Directory to PATH
    15. 8. Using Variable Substitution
    16. Example: Variable Substitution in Shell Script
    17. 9. Setting Variables in Scripts
    18. Example: Setting and Using Variables in a Script
    19. 10. Exporting Variables to Child Processes
    20. Example: Setting and Exporting a Variable
    21. Example: Running Command with Temporary Variable

  17. Configuring Shell Environment

    1. 1. Understanding Shell Configuration Files
    2. Example: Setting Environment Variables in ~/.bashrc
    3. 2. Setting Shell Prompt
    4. Example: Customizing PS1
    5. Example: Colorized Prompt
    6. 3. Creating Command Aliases
    7. Example: Define alias in .bashrc
    8. 4. Defining Shell Functions
    9. Example: Defining and Using a Bash Function
    10. Example: Function with Parameters and Return Value
    11. 5. Configuring Command History
    12. Example: Setting History Size
    13. Example: Ignoring Duplicate Commands
    14. Example: Adding Timestamps to History
    15. 6. Using History Command
    16. Example: Using history command
    17. Example: Re-executing last command
    18. 7. Searching Command History
    19. Example: Using history command
    20. Example: Re-executing last command with !!
    21. Example: Using !string to re-execute command
    22. 8. Configuring Auto-Completion
    23. Example: Bash Auto-Completion Setup
    24. Example: Zsh Auto-Completion Setup
    25. 9. Setting Default Editor
    26. Example: Setting Default Editor for Git
    27. 10. Changing Default Shell
    28. Example: Using chsh to change shell
    29. 11. Using Shell Options
    30. Example: Enabling Debug Mode

  18. Writing Bash Scripts

    1. 1. Creating Script File
    2. Example: Basic Bash Script File
    3. 2. Making Scripts Executable
    4. Example: Basic Executable Script
    5. 3. Using Variables
    6. Example: Variable Assignment and Usage
    7. Example: Exporting Variables
    8. 4. Reading User Input
    9. 5. Using Command-Line Arguments
    10. Example: Accessing Arguments
    11. Example: Looping Through Arguments
    12. Example: Handling Optional Arguments
    13. 6. Implementing Conditional Statements
    14. Example: Basic if-else
    15. Example: Nested if-else
    16. Example: Using test command
    17. 7. Using Test Conditions
    18. Example: Using test conditions in an if statement
    19. Example: Combining test conditions with logical operators
    20. 8. Implementing Loops
    21. Example: Looping Through Files
    22. Example: Nested Loops
    23. 9. Using Case Statements
    24. Example: Basic Case Statement
    25. 10. Defining Functions
    26. Example: Basic Function Definition
    27. Example: Function with Parameters
    28. Example: Function with Local Variables
    29. 11. Handling Exit Codes
    30. Example: Using exit codes in a script
    31. Example: Checking exit code of a command
    32. 12. Implementing Error Handling
    33. Example: Using set options
    34. Example: Trap usage
    35. Example: Function error handling

  19. Working with Advanced Bash Features

    1. 1. Using Arrays
    2. Example: Array Declaration and Access
    3. Example: Array Length and Append
    4. 2. Using Associative Arrays
    5. Example: Using Associative Arrays for Configuration
    6. 3. Using String Operations
    7. Example: Extracting filename and extension
    8. Example: Replacing multiple occurrences
    9. Common String Operations Summary
    10. 4. Using Arithmetic Expansion
    11. 5. Implementing Signal Handling
    12. Example: Catching SIGINT in Bash
    13. Example: Handling SIGHUP to Reload Config
    14. 6. Using Process Substitution
    15. Example: Comparing Directory Contents
    16. Example: Redirecting to a Command
    17. 7. Creating Subshells
    18. Example: Variable Scope Isolation
    19. Key Points
    20. 8. Using set Options
    21. Example: Enabling set options
    22. 9. Debugging Scripts
    23. Example: Using set -x to debug a script
    24. Example: Using set -e to exit on error
    25. 10. Using getopts for Options
    26. Example: Basic getopts usage

  20. Understanding Linux Signals

    1. 1. Viewing Available Signals
    2. Example: List all available signals using kill -l
    3. 2. Sending Signals with kill
    4. Example: Sending SIGTERM to a process by PID
    5. Example: Sending SIGKILL to a process by name
    6. 3. Understanding Common Signals
    7. Example: Sending a Signal to a Process
    8. 4. Understanding SIGINT and SIGQUIT
    9. Example: Handling SIGINT in a Bash Script
    10. Example: Sending SIGINT to a Process
    11. 5. Handling SIGHUP for Daemons
    12. Example: Reopening Log Files on SIGHUP
    13. 6. Using SIGUSR1 and SIGUSR2
    14. Example: Sending SIGUSR1 to a Process
    15. Example: Handling SIGUSR1 in a Bash Script
    16. 7. Understanding SIGSTOP and SIGCONT
    17. Example: Using SIGSTOP and SIGCONT
    18. Key Points
    19. 8. Trapping Signals in Scripts
    20. Example: Basic Signal Trapping
    21. Example: Handling SIGUSR1
    22. 9. Ignoring Signals
    23. Example: Ignoring SIGPIPE in Bash
    24. Example: Ignoring SIGALRM in C
    25. 10. Understanding Signal Propagation
    26. Example: Signal propagation in a parent-child process

  21. Managing Users and Groups

    1. 1. Creating Users
    2. Example: Create a user with a specific home directory
    3. Example: Create a user and set a password
    4. 2. Modifying User Accounts
    5. Example: Changing User Home Directory
    6. Example: Adding User to Group
    7. 3. Deleting Users
    8. Example: Delete a user without removing home directory
    9. Example: Delete a user and remove home directory
    10. 4. Setting User Passwords
    11. Example: Setting a new password for a user
    12. Example: Locking a user account
    13. Example: Configure password aging policy
    14. Password Security Best Practices
    15. 5. Creating Groups
    16. Example: Creating a Group with a Specific GID
    17. Example: Creating a System Group
    18. 6. Modifying Groups
    19. Example: Change Group Name
    20. Example: Change Group ID
    21. 7. Deleting Groups
    22. Example: Delete a group
    23. 8. Adding Users to Groups
    24. Example: Adding User to Multiple Groups
    25. 9. Removing Users from Groups
    26. Example: Remove user from a group
    27. 10. Viewing User Information
    28. Example: Viewing User Info with id
    29. Example: Viewing User Info with finger
    30. 11. Switching Users
    31. Example: Switching to another user
    32. Example: Running a command as root
    33. 12. Managing Sudo Access
    34. Example: Granting Sudo Access to a User
    35. Example: Restricting Sudo Access

  22. Managing Processes

    1. 1. Viewing Running Processes
    2. Example: Using ps aux to view processes
    3. Example: Using top to monitor processes
    4. 2. Displaying Process Tree
    5. Example: pstree with process IDs
    6. Example: ps auxf format
    7. 3. Monitoring Processes in Real-Time
    8. Example: Using htop to monitor processes
    9. Example: Watching process CPU usage every second
    10. Key Features of Process Monitoring Tools
    11. 4. Using Enhanced Process Viewer
    12. Example: Viewing process details with
    13. Key Features of htop
    14. 5. Killing Processes by PID
    15. Example: Killing a Process by PID
    16. 6. Killing Processes by Name
    17. Example: Killing a Process by Name
    18. 7. Sending Signals to Processes
    19. Example: Sending a signal to a process
    20. Example: Using pkill to send signal by name
    21. 8. Viewing Process Priority
    22. Example: Check process priority using ps command
    23. Example: View priority of a specific process
    24. 9. Changing Process Priority
    25. Example: Setting Process Priority with nice
    26. Example: Adjusting Priority of Running Process with renice
    27. 10. Running Commands in Background
    28. Example: Running a long process in background
    29. 11. Bringing Processes to Foreground
    30. Example: Bringing a background job to foreground
    31. 12. Listing Background Jobs
    32. Example: Using jobs command

  23. Working with Job Control

    1. 1. Running Background Jobs
    2. Example: Starting a Background Job
    3. Example: Resuming a Stopped Job in Background
    4. 2. Suspending Foreground Jobs
    5. Example: Suspending and Resuming a Job
    6. 3. Listing Jobs
    7. Example: Using jobs command
    8. 4. Resuming Jobs in Foreground
    9. Example: Resuming a Background Job
    10. 5. Resuming Jobs in Background
    11. Example: Resuming a suspended job in background
    12. 6. Using nohup for Persistent Processes
    13. Example: Running a Script with nohup
    14. 8. Using screen for Terminal Multiplexing
    15. Example: Starting and Managing a Screen Session
    16. Common Screen Key Bindings
    17. 9. Managing screen Sessions
    18. Example: Starting a screen session
    19. Example: Attaching to a screen session
    20. Common screen Session Management Commands
    21. 10. Using tmux for Terminal Multiplexing
    22. Example: Creating and Managing a tmux Session
    23. Common tmux Use Cases
    24. 11. Managing tmux Sessions
    25. Example: Creating and Attaching to a Session
    26. Example: Listing and Killing Sessions
    27. 12. Using tmux Panes and Windows
    28. Example: Creating a new tmux window
    29. Example: Splitting panes horizontally
    30. Example: Navigating between panes
    31. Key tmux Window and Pane Commands

  24. Managing Services with systemd

    1. 1. Starting Services
    2. Example: Starting a service
    3. 2. Stopping Services
    4. Example: Stopping a service
    5. Example: Disabling a service at boot
    6. 3. Restarting Services
    7. Example: Restarting a service
    8. Example: Conditionally restarting a service
    9. 4. Reloading Configuration
    10. Example: Reloading a Web Server Configuration
    11. 5. Checking Service Status
    12. 6. Enabling Services at Boot
    13. Example: Enable a service at boot
    14. Example: Check if a service is enabled
    15. 7. Disabling Services
    16. Example: Disabling a Service
    17. 8. Listing All Services
    18. Example: Listing all running services
    19. Example: Listing all service unit files
    20. 9. Viewing Service Dependencies
    21. Example: View service dependencies
    22. Example: View reverse dependencies
    23. 10. Masking Services
    24. Example: Masking a service
    25. Example: Unmasking a service
    26. 11. Creating Custom Service Units
    27. Example: Basic Service Unit
    28. Example: Service with Environment Variables
    29. 12. Reloading systemd Configuration
    30. Example: Reloading systemd configuration

  25. Scheduling Tasks with Cron

    1. 1. Editing Crontab
    2. Example: Adding a Cron Job
    3. 2. Listing Cron Jobs
    4. Example: Listing Cron Jobs for Current User
    5. 3. Removing Crontab
    6. 4. Understanding Cron Syntax
    7. Example: Cron Expression Breakdown
    8. Example: Running a Script Every Hour at 15 Minutes
    9. Example: Weekly Backup on Sundays at 2 AM
    10. 5. Using Special Time Strings
    11. Example: Using @daily
    12. Example: Using @reboot
    13. 6. Managing System Cron
    14. Example: Check Cron Service Status
    15. Example: Enable Cron to Start on Boot
    16. 7. Using Cron Directories
    17. Example: Creating a Daily Cron Job
    18. 8. Viewing Cron Logs
    19. Example: Check cron logs for recent entries
    20. Example: Enable detailed cron logging (syslog)
    21. 9. Scheduling with anacron
    22. Example: Basic anacron job
    23. 10. Using at for One-Time Tasks
    24. Example: Schedule a One-Time Task
    25. 11. Scheduling with systemd Timers
    26. Example: Basic systemd timer configuration

  26. Working with Package Management (Debian/Ubuntu)

    1. 1. Updating Package Lists
    2. Example: Updating package lists and checking for upgrades
    3. 2. Upgrading Packages
    4. Example: Upgrade all packages
    5. 3. Installing Packages
    6. Example: Installing a package with dependencies
    7. Installation Summary
    8. 4. Removing Packages
    9. Example: Removing a Package
    10. Example: Purging a Package
    11. 5. Searching for Packages
    12. Example: Search for packages containing "mysql"
    13. 6. Showing Package Information
    14. Example: Displaying package info with apt show
    15. Example: Listing installed packages
    16. 7. Listing Installed Packages
    17. Example: Using dpkg to list installed packages
    18. Example: Using apt list to show installed packages
    19. 8. Cleaning Package Cache
    20. Example: Cleaning Package Cache
    21. 9. Managing Repositories
    22. Example: Adding a Repository
    23. Example: Removing a Repository
    24. Workflow: Adding a Third-Party Repository
    25. 10. Installing DEB Packages
    26. Example: Installing a local DEB package
    27. 11. Resolving Dependencies
    28. Example: Resolving Dependency Conflicts
    29. 12. Holding Package Versions
    30. Example: Holding a Package Version

  27. Working with Package Management (RHEL/CentOS)

    1. 1. Checking for Updates
    2. Example: Checking for updates for a specific package
    3. 2. Upgrading Packages
    4. Example: Update a specific package
    5. Example: Update all packages with security fixes
    6. 3. Installing Packages
    7. Example: Install Apache Web Server
    8. 4. Removing Packages
    9. Example: Removing a Package with YUM
    10. Example: Removing a Package with DNF
    11. 5. Searching for Packages
    12. Example: Search for packages containing "node"
    13. Example: Search all package metadata for "mysql"
    14. 6. Showing Package Information
    15. Example: Displaying package information
    16. Example: Listing files in a package
    17. Example: Finding package owner of a file
    18. 7. Listing Installed Packages
    19. Example: Find all packages related to Python
    20. 8. Cleaning Package Cache
    21. Example: Cleaning package cache
    22. 9. Managing Repositories
    23. Example: Adding a Custom Repository
    24. Workflow: Enable a Repository
    25. Comparison: YUM vs DNF
    26. 10. Installing RPM Packages
    27. Example: Installing a Package
    28. 11. Querying RPM Packages
    29. Example: Find package that owns a file
    30. Example: List all files in a package
    31. 12. Verifying Package Integrity
    32. Example: Verifying Package Integrity
    33. Example: Checking Package Signature

  28. Managing System Logs with journald

    1. 1. Viewing System Logs
    2. Example: View logs for the nginx service
    3. Example: View logs from the last hour
    4. Example: Follow logs in real-time with priority filter
    5. 2. Following Logs in Real-Time
    6. Example: Following Logs in Real-Time
    7. Example: Following Logs from a Service
    8. Example: Following Logs from a Specific Time
    9. 3. Filtering by Service
    10. Example: Filter logs for a specific service
    11. 4. Filtering by Time Range
    12. Example: Filtering logs from the last 15 minutes
    13. Example: Filtering logs between two specific timestamps
    14. 5. Filtering by Priority
    15. Example: Filtering Logs by Priority Level
    16. Example: Combining Priority with Time Range
    17. 6. Viewing Boot Logs
    18. Example: View boot logs with timestamp
    19. 7. Viewing Logs for Specific PID
    20. Example: View logs for a specific PID
    21. Example: View logs for a specific PID with time range
    22. 8. Exporting Logs
    23. Example: Exporting logs to a file
    24. Example: Exporting logs with a time range
    25. 9. Configuring Journal Storage
    26. Example: Journal Storage Configuration
    27. 10. Clearing Journal Logs
    28. Example: Clearing Journal Logs by Size
    29. Example: Clearing Journal Logs by Time
    30. 11. Viewing Kernel Messages
    31. Example: View kernel messages from current boot
    32. Example: View kernel messages from last boot with timestamp
    33. Summary of Kernel Log Filtering Options
    34. 12. Searching Logs
    35. Example: Search logs from last hour
    36. Example: Search logs with specific message pattern
    37. Example: Search logs from a specific service

  29. Managing Traditional System Logs

    1. 1. Understanding Syslog Architecture
    2. Example: Syslog Message Format
    3. Example: Basic rsyslog Configuration
    4. Key Concepts in Syslog Architecture
    5. 2. Reading Log Files
    6. Example: Viewing Log Files with
    7. Example: Filtering Logs by Timestamp
    8. Example: Using
    9. 3. Viewing Authentication Logs
    10. Example: Filter Failed Login Attempts
    11. Example: Monitor Real-Time Authentication Events
    12. 4. Viewing System Messages
    13. Example: Using journalctl to view recent logs
    14. Example: Filtering logs by service
    15. 5. Following Logs with tail
    16. Example: Following system logs in real-time
    17. Example: Following last 20 lines of a log file
    18. 6. Configuring rsyslog
    19. Example: Basic rsyslog configuration
    20. Example: Filtering logs by facility and priority
    21. 7. Rotating Logs
    22. Example: Basic logrotate configuration
    23. 8. Configuring Log Rotation
    24. Example: Basic logrotate configuration for a web server
    25. 9. Sending Logs to Remote Server
    26. Example: Configure rsyslog to send logs to remote server
    27. 10. Using logger Command
    28. Example: Logging a message with logger

  30. Managing Disk Space

    1. 1. Viewing Disk Usage
    2. Example: Check disk usage of root directory
    3. Example: Find largest directories in home folder
    4. 2. Checking Directory Size
    5. Example: Check directory size
    6. Example: Check all subdirectories size
    7. 3. Analyzing Disk Usage
    8. Example: Check disk usage of current directory
    9. Example: Using ncdu for interactive disk usage analysis
    10. Common du options
    11. 4. Finding Large Files
    12. Example: Find files larger than 100MB
    13. Example: Find files larger than 1GB
    14. Example: Find files larger than 1GB and sort by size
    15. 5. Checking Inode Usage
    16. Example: Check inode usage on root filesystem
    17. 6. Viewing Block Devices
    18. Example: Using lsblk to view block devices
    19. Example: Using fdisk to view partition layout
    20. 7. Displaying Partition Table
    21. Example: Using lsblk to display partition table
    22. 8. Mounting File Systems
    23. Example: Mounting a USB Drive
    24. Example: Auto-mounting with /etc/fstab
    25. 9. Unmounting File Systems
    26. Example: Unmounting a USB Drive
    27. 10. Viewing Mounted File Systems
    28. Example: Check disk usage for a specific directory
    29. 11. Configuring Automatic Mounts
    30. Example: Adding a New Mount Point
    31. 12. Checking File System
    32. Example: Check disk usage of root directory

  31. Managing Partitions and File Systems

    1. 1. Creating Partitions with fdisk
    2. Example: Create a new partition using fdisk
    3. 2. Creating Partitions with parted
    4. Example: Create a new partition table and add a partition
    5. 3. Creating GPT Partitions
    6. Example: Using gdisk to create a new GPT partition
    7. 4. Creating ext4 File System
    8. Example: Create ext4 File System
    9. 5. Creating XFS File System
    10. Example: Create XFS File System
    11. Key Features of XFS
    12. 6. Creating Btrfs File System
    13. Example: Create Btrfs File System
    14. 7. Creating FAT32 File System
    15. Example: Create FAT32 File System
    16. 8. Resizing ext File Systems
    17. Example: Resizing an ext4 filesystem to 10GB
    18. 9. Resizing XFS File Systems
    19. Example: Growing an XFS Filesystem
    20. Example: Checking XFS Filesystem Size
    21. Key Points
    22. 10. Tuning File System Parameters
    23. Example: Adjusting swappiness to reduce swapping
    24. Example: Setting maximum file handles system-wide
    25. 11. Checking File System Type
    26. Example: Identifying File System Type
    27. 12. Using Btrfs Subvolumes
    28. Example: Creating and Using Subvolumes
    29. Example: Creating a Snapshot
    30. Key Features of Btrfs Subvolumes

  32. Managing Swap Space

    1. 1. Viewing Swap Usage
    2. Example: Check current swap usage with free
    3. Example: List all active swap spaces
    4. 2. Creating Swap Partition
    5. Example: Enabling Swap
    6. 3. Enabling Swap Partition
    7. Example: Enabling Swap Partition
    8. 4. Creating Swap File
    9. Example: Create a 1GB Swap File
    10. Example: Make Swap File Permanent
    11. 5. Setting Up Swap File
    12. Example: Verify Swap Activation
    13. Swap File Configuration Summary
    14. 6. Configuring Permanent Swap
    15. 7. Disabling Swap
    16. Example: Disable all swap spaces
    17. 8. Adjusting Swap Priority
    18. Example: Setting swappiness to 10
    19. Example: Making swappiness persistent across reboots
    20. 9. Tuning Swappiness
    21. Example: Setting Swappiness to 10
    22. Example: Making Swappiness Change Permanent
    23. 10. Monitoring Swap Activity
    24. Example: Check current swap usage
    25. Example: Monitor swap usage over time

  33. Managing LVM Volumes

    1. 1. Understanding LVM Concepts
    2. Example: Creating a basic LVM setup
    3. Key Benefits of LVM
    4. 2. Creating Physical Volumes
    5. Example: Creating a Physical Volume
    6. 3. Viewing Physical Volumes
    7. Example: Using pvs command
    8. Example: Using pvs with verbose flag
    9. 4. Creating Volume Groups
    10. Example: Creating a Volume Group with Two Physical Volumes
    11. 5. Viewing Volume Groups
    12. Example: Displaying Volume Group Details
    13. 6. Extending Volume Groups
    14. Example: Extending Volume Group with New Disk
    15. 7. Creating Logical Volumes
    16. Example: Create a 5GB Logical Volume
    17. 8. Viewing Logical Volumes
    18. Example: View all logical volumes with full details
    19. 9. Extending Logical Volumes
    20. Example: Extend Logical Volume by Size
    21. Example: Extend Logical Volume to Use All Free Space
    22. Example: Extend XFS Filesystem After Extending LV
    23. Example: Extend ext4 Filesystem After Extending LV
    24. 10. Resizing File Systems
    25. Example: Resizing ext4 File System
    26. Example: Resizing XFS File System
    27. 11. Creating LVM Snapshots
    28. Example: Creating a Snapshot
    29. Snapshot Creation Steps
    30. 12. Removing LVM Components
    31. Example: Remove Logical Volume
    32. Workflow: Remove LVM Components Safely

  34. Configuring RAID Arrays

    1. 1. Understanding RAID Levels
    2. 2. Creating RAID with mdadm
    3. Example: Create a RAID 1 Array
    4. RAID Level Summary
    5. 3. Viewing RAID Status
    6. Example: Check RAID status with mdadm
    7. Example: List all RAID arrays
    8. Example: Monitor RAID rebuild progress
    9. 4. Adding Disks to RAID
    10. Example: Adding a Disk to RAID 1 Array
    11. 5. Removing Failed Disks
    12. Example: Removing and Replacing a Disk
    13. 6. Stopping RAID Arrays
    14. Example: Stopping a RAID Array
    15. 7. Assembling RAID Arrays
    16. Example: Assemble a RAID 1 Array
    17. Example: Assemble with Configuration File
    18. Assembling Process Summary
    19. 8. Saving RAID Configuration
    20. Example: Save RAID configuration using mdadm
    21. 9. Monitoring RAID Health
    22. Example: Check RAID Status with mdadm
    23. Example: View RAID Events with journalctl
    24. Example: Monitor RAID with /proc/mdstat
    25. 10. Growing RAID Arrays
    26. Example: Adding a new drive to an existing RAID 5 array

  35. Configuring Hostname and DNS

    1. 1. Viewing Hostname
    2. Example: Displaying Hostname
    3. 2. Setting Hostname
    4. Example: Setting Hostname with hostnamectl
    5. 3. Configuring Static Hostname
    6. Example: Setting Static Hostname Using hostnamectl
    7. Summary of Hostname Configuration Methods
    8. 4. Understanding hosts File
    9. Example: hosts file entry
    10. Key Points
    11. 5. Adding Local DNS Entries
    12. Example: Adding a local DNS entry for a development server
    13. 6. Configuring DNS Resolvers
    14. Example: Adding DNS Resolver
    15. 7. Understanding NSSwitch
    16. Example: NSSwitch Configuration
    17. 8. Using systemd-resolved
    18. Example: Basic systemd-resolved configuration
    19. Workflow: Setting up systemd-resolved
    20. 9. Configuring Search Domains
    21. Example: Setting Search Domains
    22. 10. Testing DNS Resolution
    23. Example: Using dig to query DNS records
    24. Example: Using nslookup to resolve a hostname

  36. Configuring Network Interfaces

    1. 1. Viewing Network Interfaces
    2. Example: Displaying interface details with
    3. 2. Configuring IP Addresses
    4. Example: Assigning Static IP Address Using ip Command
    5. Example: Viewing Assigned IP Addresses
    6. 3. Enabling and Disabling Interfaces
    7. Example: Enabling an Interface
    8. Example: Disabling an Interface
    9. 4. Viewing Routing Table
    10. Example: Displaying routing table with ip route
    11. 5. Adding Static Routes
    12. Example: Adding a Static Route Using ip Command
    13. Example: Adding a Static Route Using route Command
    14. 6. Deleting Routes
    15. Example: Delete a specific route using ip command
    16. 7. Setting Default Gateway
    17. Example: Using ip command to set default gateway
    18. 8. Configuring DNS Servers
    19. Example: Setting DNS Servers via /etc/resolv.conf
    20. 9. Testing Network Connectivity
    21. Example: Check if a server is reachable
    22. Example: Diagnose network path issues
    23. Network Connectivity Testing Summary
    24. 10. Viewing Network Statistics
    25. Example: Monitor Network Traffic
    26. Example: Show Interface Statistics
    27. 11. Managing Network with NetworkManager
    28. Example: Configure a new Ethernet Connection
    29. Example: List All Active Connections
    30. 12. Configuring Network Bonds
    31. Example: Creating a Bond Interface
    32. Example: Bond Configuration in /etc/network/interfaces

  37. Troubleshooting Network Issues

    1. 1. Tracing Network Path
    2. Example: Using traceroute to diagnose network path
    3. 2. Checking DNS Resolution
    4. Example: Using dig to check DNS resolution
    5. 3. Viewing Open Ports and Connections
    6. Example: Using ss to view listening ports with process info
    7. Example: Using netstat to view all TCP connections
    8. 4. Scanning Network Ports
    9. Example: Scan all ports on localhost using nmap
    10. Example: Check if port 22 is open using netcat
    11. 5. Testing TCP Connections
    12. Example: Using netcat to test TCP connection
    13. 6. Capturing Network Packets
    14. Example: Capture packets with tcpdump
    15. Example: Filter packets by protocol
    16. Example: Display packets in real-time
    17. 7. Analyzing Network Traffic
    18. Example: Capture HTTP traffic with tcpdump
    19. Example: Filter traffic by port using tshark
    20. 8. Checking Network Performance
    21. Example: Measuring Latency with ping
    22. Example: Monitoring Bandwidth with iftop
    23. 9. Displaying ARP Cache
    24. Example: Viewing ARP cache using ip neigh
    25. ARP Cache Status Values
    26. 10. Flushing DNS Cache
    27. Example: Flushing DNS Cache on Ubuntu 22.04
    28. 11. Diagnosing with curl and wget
    29. Example: Testing HTTP connectivity with curl
    30. Example: Using wget to test URL availability

  38. Managing Firewall with iptables

    1. 1. Viewing iptables Rules
    2. 2. Understanding Chains
    3. Example: View Current Chains
    4. 3. Adding Rules
    5. 4. Deleting Rules
    6. Example: Delete a specific rule by number
    7. Example: Delete rule by matching criteria
    8. 5. Setting Default Policies
    9. Example: Setting Default Input Policy to DROP
    10. 6. Filtering by Source and Destination
    11. Example: Allow traffic from specific subnet to a server
    12. Example: Block traffic from specific IP to a service
    13. 7. Filtering by Port
    14. Example: Allow incoming connections on port 80
    15. Example: Block all traffic on port 2222
    16. 8. Filtering by Protocol
    17. Example: Allow TCP traffic on port 443
    18. Example: Drop UDP traffic on port 53
    19. 9. Using Connection Tracking
    20. Example: View Active Connections
    21. Example: Flush All Connections
    22. 10. NAT and Port Forwarding
    23. Example: Set up Port Forwarding
    24. 11. Saving iptables Rules
    25. Example: Save iptables rules to file
    26. 12. Logging Traffic
    27. Example: Log All Denied Packets
    28. Example: Log TCP Connections

  39. Managing Firewall with ufw and firewalld

    1. 1. Viewing Firewall Status
    2. Example: Check ufw status
    3. Example: Check firewalld state
    4. 2. Enabling and Disabling Firewall
    5. Example: Enabling ufw firewall
    6. Example: Disabling ufw firewall
    7. Example: Checking ufw status
    8. Example: Reloading firewalld
    9. 3. Allowing Ports
    10. Example: Allow HTTP traffic
    11. Example: Allow SSH from a specific IP
    12. 4. Denying Ports
    13. Example: Deny incoming SSH access
    14. Example: Deny traffic from a specific IP
    15. 5. Allowing Services
    16. Example: Allow SSH service
    17. Example: Allow HTTP and HTTPS services
    18. Example: Allow specific port range (e.g., custom game server)
    19. 6. Deleting Rules
    20. Example: Delete a specific rule by position
    21. Example: Delete a rule by matching content
    22. 7. Configuring Default Policies
    23. Example: Setting Default Incoming Policy to Deny
    24. Example: Setting Default Outgoing Policy to Allow
    25. 8. Managing Zones
    26. Example: List available zones
    27. Example: Set default zone
    28. Example: Allow traffic from specific zone
    29. 9. Creating Rich Rules
    30. Example: Allow SSH from specific IP
    31. Example: Block traffic from a specific IP
    32. 10. Saving Firewall Rules
    33. Example: Save ufw rules to disk
    34. Example: Save firewalld runtime rules permanently

  40. Working with SSH and Remote Access

    1. 1. Connecting to Remote Host
    2. Example: Basic SSH Connection
    3. Example: SSH with Custom Port
    4. Example: SSH with Specific Key
    5. 2. Using SSH with Custom Port
    6. Example: SSH Connection to Custom Port
    7. 3. Copying Files with SCP
    8. Example: Copying a file to a remote server
    9. Example: Copying a directory recursively
    10. 4. Synchronizing Files with rsync
    11. Example: Basic rsync command
    12. Example: Sync with delete
    13. Example: Dry run to preview changes
    14. 5. Generating SSH Keys
    15. Example: Generate RSA Key Pair
    16. Example: Generate Ed25519 Key Pair
    17. Key Generation Best Practices
    18. 6. Copying Public Key
    19. Example: Copying a public key to a remote server
    20. 7. Configuring SSH Client
    21. Example: Basic SSH Client Configuration
    22. Example: SSH Client with ProxyJump
    23. 8. Configuring SSH Server
    24. Example: Basic SSH Server Configuration
    25. Key SSH Server Configuration Options
    26. 9. Creating SSH Tunnels
    27. Example: Local Port Forwarding
    28. Example: Remote Port Forwarding
    29. Example: SOCKS Proxy
    30. 10. Managing SSH Agent
    31. Example: Start SSH Agent and Add Key
    32. 11. Using ProxyJump
    33. Example: SSH through a jump host
    34. Benefits of SSH Multiplexing

  41. Working with Network File Systems

    1. 1. Installing NFS Server
    2. Example: Configure NFS Export
    3. 2. Configuring NFS Exports
    4. Example: /etc/exports configuration
    5. Example: Applying NFS exports
    6. 3. Exporting NFS Shares
    7. Example: Basic NFS Export Configuration
    8. Steps to Export an NFS Share
    9. 4. Mounting NFS Shares
    10. Example: Mounting an NFS Share
    11. Example: Mounting with Options
    12. 5. Configuring NFS Client
    13. Example: Mounting an NFS Share
    14. Example: Mounting with Specific Options
    15. 6. Installing Samba Server
    16. Example: Basic Samba Configuration
    17. 7. Configuring Samba Shares
    18. Example: Basic Samba Configuration
    19. Example: Setting Up Samba Share with User Authentication
    20. Workflow: Setting Up Samba Share
    21. 8. Creating Samba Users
    22. Example: Adding a new Samba user
    23. Example: Disabling a Samba user
    24. 9. Mounting CIFS Shares
    25. Example: Mounting a CIFS Share
    26. 10. Using autofs for Auto-Mounting
    27. Example: Basic autofs configuration
    28. Steps to set up autofs
    29. Key Features of autofs

  42. Monitoring System Resources

    1. 1. Viewing Memory Usage
    2. Example: Using free -h to view memory usage
    3. Example: Using cat /proc/meminfo to view detailed memory info
    4. 2. Monitoring CPU Usage
    5. Example: Using
    6. Example: Using
    7. Example: Using
    8. 3. Displaying Load Average
    9. Example: Interpreting Load Average
    10. 4. Monitoring I/O Statistics
    11. Example: Using iostat to Monitor Disk I/O
    12. Example: Using iotop to Monitor I/O by Processes
    13. 5. Viewing Real-Time Disk Activity
    14. Example: Using iostat to view disk activity
    15. Example: Using iotop to view real-time I/O by process
    16. 6. Checking System Temperature
    17. Example: Using sensors command
    18. Example: Reading raw temperature values
    19. 7. Monitoring Network Bandwidth
    20. Example: Using iftop to monitor bandwidth
    21. Example: Using nethogs to view per-process bandwidth
    22. Key Features of Network Monitoring Tools
    23. 8. Using System Activity Reporter
    24. Example: Basic system activity report
    25. Example: Monitor disk I/O every 2 seconds for 3 times
    26. Example: Display network statistics
    27. 9. Viewing System Statistics
    28. Example: Using top to monitor CPU usage
    29. Example: Using vmstat to check memory usage
    30. 10. Analyzing System Performance
    31. Example: Using
    32. Example: Monitoring disk I/O with
    33. 11. Viewing Open Files and Processes
    34. Example: View all processes using port 80
    35. Example: Find process ID by name
    36. Example: List all open files for a specific process

  43. Gathering System Information

    1. 1. Displaying CPU Information
    2. Example: Get CPU model name
    3. Example: Show CPU cores and threads
    4. 2. Viewing Memory Information
    5. Example: Using free with different units
    6. Example: Monitoring memory usage over time
    7. 3. Listing PCI Devices
    8. Example: Display all PCI devices with verbose output
    9. Example: Display only devices on bus 0000:00
    10. 4. Listing USB Devices
    11. Example: Find USB device by vendor ID
    12. 5. Viewing Block Devices
    13. Example: Identify mounted filesystems on block devices
    14. 6. Displaying Hardware Information
    15. Example: Using lshw to get detailed hardware info
    16. Example: Displaying network hardware info
    17. 7. Listing Loaded Modules
    18. Example: Using lsmod to list loaded modules
    19. Example: Using modinfo to get details of a module
    20. 8. Viewing BIOS Information
    21. Example: Display BIOS Information
    22. 9. Checking Manufacturer Information
    23. Example: Retrieve System Manufacturer
    24. 10. Viewing System Statistics
    25. Example: Using vmstat to check memory usage
    26. Example: Using iostat to monitor disk I/O

  44. Managing Hardware Devices

    1. 1. Viewing Device Information
    2. Example: View disk usage and partitions
    3. Example: Show detailed CPU info
    4. 2. Monitoring Hardware with sensors
    5. Example: Displaying sensor data
    6. 3. Testing Hard Drives
    7. Example: Check drive health with SMART
    8. Example: Test read/write speed with dd
    9. 4. Viewing Disk SMART Status
    10. Example: Check SMART status of /dev/sda
    11. SMART Status Indicators
    12. 5. Managing USB Devices
    13. Example: Identify USB device by vendor ID
    14. Example: View USB device details using udevadm
    15. 6. Configuring Sound Devices
    16. Example: Basic ALSA Configuration
    17. Example: Setting Default Audio Device
    18. 7. Managing Graphics Drivers
    19. Example: Install NVIDIA Driver
    20. Example: Check Driver Status
    21. 8. Controlling Laptop Brightness
    22. Example: Using brightnessctl to adjust brightness
    23. Example: Increasing brightness by 10%
    24. Example: Getting current brightness level
    25. 9. Managing Power Settings
    26. Example: Check power usage
    27. Example: Set CPU governor
    28. 10. Configuring Bluetooth
    29. Example: Enable Bluetooth on Boot
    30. Example: Pairing a Bluetooth Device
    31. 11. Viewing Battery Status
    32. Example: Check battery status with acpi
    33. Example: Read battery capacity directly

  45. Managing Time and Localization

    1. 1. Viewing Current Time
    2. Example: Displaying formatted time
    3. 2. Setting System Time
    4. Example: Setting System Time with timedatectl
    5. 3. Configuring Time Zone
    6. Example: Setting Timezone
    7. 4. Synchronizing Time with NTP
    8. Example: Check NTP Status
    9. 5. Viewing NTP Status
    10. Example: Check NTP synchronization status
    11. 6. Configuring Hardware Clock
    12. Example: Setting Hardware Clock
    13. 7. Setting System Locale
    14. Example: Setting Locale via Environment Variable
    15. Example: Permanently Setting Locale in /etc/default/locale
    16. 8. Viewing Available Locales
    17. Example: List available locales using locale command
    18. Example: Display current locale settings
    19. 9. Generating Locales
    20. Example: Check Available Locales
    21. Example: Generate New Locale
    22. 10. Configuring Keyboard Layout
    23. Example: Set Keyboard Layout Using localectl
    24. Example: Set Keyboard Layout Using setxkbmap

  46. Understanding Boot Process

    1. 1. Understanding BIOS vs UEFI Boot Sequence
    2. Example: UEFI Boot Process Overview
    3. 2. Understanding GRUB Bootloader
    4. Example: GRUB Configuration
    5. Example: Update GRUB Configuration
    6. GRUB Bootloader Overview
    7. 3. Configuring GRUB Settings
    8. Example: Modifying GRUB_TIMEOUT
    9. 4. Accessing GRUB Menu
    10. Example: Modifying GRUB Timeout
    11. 5. Booting into Single-User Mode
    12. Example: Booting into Single-User Mode
    13. 6. Understanding systemd Boot Targets
    14. Example: Check current boot target
    15. Example: Change boot target to graphical
    16. 7. Setting Default Boot Target
    17. Example: Change default boot target to graphical mode
    18. 8. Viewing Boot Messages
    19. Example: View boot messages with dmesg
    20. Example: Use journalctl to view boot logs
    21. 9. Repairing GRUB
    22. Example: Boot into Live USB and Repair GRUB
    23. 10. Using Emergency Mode
    24. Example: Booting into Emergency Mode
    25. Example: Using GRUB to Enter Emergency Mode

  47. Managing Kernel and Modules

    1. 1. Viewing Loaded Modules
    2. Example: Check if a specific module is loaded
    3. 2. Loading Modules Manually
    4. Example: Load a module with modprobe
    5. Example: Load a module with insmod
    6. Example: Unload a module with rmmod
    7. 3. Removing Modules
    8. Example: Removing a Kernel Module
    9. 4. Viewing Module Information
    10. Example: Check module details
    11. 5. Configuring Module Parameters
    12. Example: Setting Module Parameter
    13. Example: Persistent Parameter Configuration
    14. 6. Blacklisting Modules
    15. Example: Blacklisting a Module
    16. 7. Updating Kernel
    17. Example: Update kernel on Ubuntu
    18. Update Process Summary
    19. 8. Viewing Available Kernels
    20. Example: Check running kernel version
    21. Example: List installed kernels (Debian/Ubuntu)
    22. 9. Removing Old Kernels
    23. Example: Remove Old Kernels
    24. 10. Managing initramfs
    25. Example: Update initramfs after kernel update
    26. Example: Create a new initramfs image

  48. Managing Kernel Parameters

    1. 1. Viewing Kernel Parameters
    2. Example: View IP Forwarding Setting
    3. 2. Displaying Specific Parameter
    4. Example: Displaying a specific kernel parameter
    5. 3. Setting Temporary Parameters
    6. Example: Temporarily set a kernel parameter
    7. 4. Setting Permanent Parameters
    8. Example: Setting a permanent parameter
    9. 5. Reloading sysctl Configuration
    10. Example: Reloading sysctl Configuration
    11. 6. Tuning Network Parameters
    12. Example: Setting network parameters via sysctl
    13. Example: Making changes persistent
    14. 7. Tuning Memory Parameters
    15. Example: Setting swappiness to 10
    16. Example: Making swappiness persistent
    17. 8. Configuring TCP/IP Stack
    18. Example: Modifying TCP/IP Parameters
    19. Example: Making Changes Persistent
    20. 9. Loading Modules at Boot
    21. Example: Loading a module at boot using
    22. Example: Loading a module with options using
    23. Example: Setting module options using
    24. 10. Understanding /proc and /sys Filesystems
    25. Example: View kernel parameters via /proc
    26. Example: Modify kernel parameter via /sys

  49. Implementing System Security

    1. 1. Configuring Firewall
    2. Example: Allow SSH Access
    3. Example: Deny HTTP Access
    4. 2. Managing SSH Security
    5. Example: SSH Configuration File
    6. SSH Security Best Practices
    7. 3. Updating System Packages
    8. Example: Update and upgrade system packages
    9. 4. Implementing Fail2ban
    10. Example: Basic jail configuration
    11. Example: Custom filter for application logs
    12. 5. Auditing System with Lynis
    13. Example: Running Lynis Audit
    14. Key Features of Lynis
    15. 6. Scanning for Rootkits
    16. Example: Using chkrootkit
    17. Example: Using rkhunter
    18. 7. Setting Password Policies
    19. Example: Enforcing password complexity
    20. 8. Enforcing Password Complexity
    21. Example: Setting Password Policy
    22. 9. Using sudo Securely
    23. Example: Securely running a command as root
    24. Best Practices for sudo Usage
    25. 10. Implementing File Integrity Monitoring
    26. Example: AIDE Configuration
    27. Example: AIDE Database Initialization
    28. 11. Securing Shared Memory
    29. Example: Setting Shared Memory Limits
    30. Example: Making Changes Permanent
    31. 12. Disabling Unnecessary Services
    32. Example: Disable a service using systemctl

  50. Understanding Linux Capabilities

    1. 1. Understanding Capability Types
    2. Example: Setting Capabilities on a Binary
    3. 2. Viewing File Capabilities
    4. Example: Using getcap to view file capabilities
    5. Example: Using getcap on a directory
    6. 3. Setting File Capabilities
    7. Example: Setting Capabilities on a Binary
    8. Summary of Capabilities
    9. 4. Viewing Process Capabilities
    10. Example: Check Capabilities of a Process
    11. Example: View Capabilities of a Running Process
    12. Example: Set Capabilities on an Executable
    13. 5. Understanding Capability Sets
    14. Example: Viewing Current Capabilities
    15. Example: Setting Capabilities on a Binary
    16. 6. Using capsh for Testing
    17. Example: Testing capabilities with capsh
    18. 7. Dropping Capabilities
    19. Example: Dropping Capabilities with capsh
    20. 8. Understanding Capability Bounding Set
    21. Example: Setting capability bounding set
    22. 9. Comparing Capabilities vs SUID
    23. Example: Setting Capabilities
    24. Example: Setting SUID
    25. 10. Managing Capabilities with systemd
    26. Example: systemd service with capabilities
    27. Summary of systemd Capabilities

  51. Managing Audit System

    1. 1. Installing and Enabling auditd
    2. Example: Basic auditd configuration
    3. 2. Viewing Audit Rules
    4. Example: View current audit rules
    5. 3. Adding File Watch Rules
    6. Example: Adding a File Watch Rule
    7. 4. Adding System Call Rules
    8. Example: Adding a System Call Rule
    9. 5. Searching Audit Logs
    10. Example: Search for login events in the last hour
    11. Example: Search for all failed login attempts
    12. 6. Generating Audit Reports
    13. Example: Generate a user activity report
    14. Example: Export audit report to a file
    15. 7. Configuring Audit Rules
    16. Example: Basic Audit Rule Configuration
    17. 8. Managing Audit Log Rotation
    18. Example: Configuring Audit Log Rotation
    19. Steps to Rotate Audit Logs Manually
    20. 9. Filtering Audit Events
    21. Example: Filtering by syscall and UID
    22. Example: Filtering by architecture and syscall
    23. 10. Understanding Audit Log Format
    24. Example: Audit Log Entry

  52. Working with SELinux

    1. 1. Checking SELinux Status
    2. Example: Check SELinux status in a script
    3. 2. Setting SELinux Mode
    4. Example: Temporarily switch to permissive mode
    5. Example: Permanently set enforcing mode
    6. 3. Viewing Security Contexts
    7. Example: Check security context of a file
    8. Example: View process security context
    9. 4. Changing File Context
    10. Example: Change context for a web file
    11. 5. Restoring Default Context
    12. Example: Restoring Context to Web Content
    13. 6. Managing Policy Booleans
    14. Example: Toggle a Policy Boolean
    15. 7. Viewing SELinux Denials
    16. Example: Check SELinux denials using auditctl
    17. Example: Using sealert to analyze denials
    18. 8. Creating Custom Policies
    19. Example: Define a Custom Policy Module
    20. Example: Compile and Install Custom Policy
    21. 9. Managing SELinux Users
    22. Example: Adding a New SELinux User
    23. Example: Viewing SELinux User Mappings
    24. 10. Configuring Port Labels
    25. Example: Setting Port Label with semanage
    26. Example: Viewing Current Port Labels
    27. 11. Troubleshooting SELinux Issues
    28. Example: Check SELinux status and logs
    29. Example: Temporarily disable SELinux for testing
    30. SELinux Troubleshooting Workflow

  53. Working with AppArmor

    1. 1. Checking AppArmor Status
    2. Example: Checking AppArmor Status
    3. 2. Listing AppArmor Profiles
    4. Example: Listing AppArmor Profiles
    5. 3. Setting Profile Modes
    6. Example: Setting Profile Mode
    7. 4. Viewing Profile Definitions
    8. Example: View loaded AppArmor profiles
    9. Example: View profile definition file
    10. 5. Creating Custom Profiles
    11. Example: Basic AppArmor Profile Structure
    12. Workflow: Creating and Loading a Custom AppArmor Profile
    13. 6. Updating Profiles
    14. Example: Updating a Profile
    15. 7. Disabling Profiles
    16. Example: Temporarily disabling a profile
    17. Example: Permanently disabling a profile
    18. 8. Reloading Profiles
    19. Example: Reloading a Profile
    20. 9. Debugging Profile Issues
    21. Example: Check AppArmor status
    22. Example: View AppArmor logs
    23. Workflow: Troubleshoot AppArmor Profile Issues
    24. 10. Understanding AppArmor vs SELinux
    25. AppArmor vs SELinux: Key Differences

  54. Working with Containers and Namespaces

    1. 1. Understanding Namespaces
    2. Example: Creating a Network Namespace
    3. 2. Understanding Control Groups
    4. Example: Creating a new cgroup
    5. 3. Using systemd-nspawn
    6. Example: Running a container with systemd-nspawn
    7. Example: Running a container with port forwarding
    8. Key Features of systemd-nspawn
    9. 4. Creating Isolated Environments
    10. Example: Basic Namespace Isolation
    11. Example: Using User Namespace for Isolation
    12. Key Concepts in Namespace Isolation
    13. 5. Managing Resource Limits
    14. Example: Setting Memory Limit
    15. Example: Setting CPU Quota
    16. 6. Using unshare for Namespaces
    17. Example: Running a command in a new mount namespace
    18. Example: Isolating a process in a new PID namespace
    19. 7. Viewing Container Processes
    20. Example: Viewing Container Processes in a Namespace
    21. 8. Configuring cgroups v2
    22. Example: Enabling CPU and Memory Controllers
    23. Example: Setting CPU Quota
    24. Example: Limiting Memory Usage
    25. 9. Limiting CPU Usage
    26. Example: Setting CPU Quota
    27. 10. Limiting Memory Usage
    28. Example: Setting Memory Limits in cgroup

  55. Backing Up and Recovering Data

    1. 1. Creating Backups with tar
    2. Example: Creating a compressed backup
    3. Example: Extracting a backup
    4. 2. Creating Incremental Backups
    5. Example: Using rsync for incremental backups
    6. 3. Backing Up with rsync
    7. Example: Basic rsync backup
    8. Example: Backup with deletion and compression
    9. 4. Creating Disk Images
    10. Example: Creating a disk image with dd
    11. Example: Using ddrescue for bad sector handling
    12. 5. Cloning Partitions with dd
    13. Example: Clone a Partition Using dd
    14. 6. Using rsnapshot for Snapshots
    15. Example: Basic rsnapshot Configuration
    16. Example: Running rsnapshot Backup
    17. 7. Backing Up with Duplicity
    18. Example: Basic Backup Command
    19. 8. Restoring from Backups
    20. Example: Restore a Directory from Tar Archive
    21. 9. Scheduling Automated Backups
    22. Example: Cron Job for Daily Backup
    23. Example: Weekly Backup with Log
    24. 10. Testing Backup Integrity
    25. Example: Verify integrity of a tar backup using checksums

  56. Optimizing System Performance

    1. 1. Identifying Performance Bottlenecks
    2. Example: Using
    3. Example: Using
    4. Common Performance Bottlenecks
    5. 2. Tuning Swap Usage
    6. Example: Adjusting Swap Settings
    7. 3. Optimizing File System Performance
    8. Example: Mounting tmpfs with optimized size
    9. Example: Setting io.scheduler for SSD
    10. 4. Tuning I/O Scheduler
    11. Example: Setting I/O Scheduler for a Disk Device
    12. 5. Configuring CPU Governor
    13. Example: Check current CPU governor
    14. Example: Set CPU governor to performance
    15. 6. Managing Process Priorities
    16. Example: Setting Process Priority with nice
    17. Example: Changing Priority of Running Process with renice
    18. 7. Using Huge Pages
    19. Example: Allocating Huge Pages
    20. Example: Checking Huge Page Usage
    21. 8. Optimizing Network Stack
    22. Example: Apply network optimizations
    23. 9. Disabling Unnecessary Services
    24. Example: Disable a service permanently
    25. 10. Analyzing Performance with perf
    26. Example: Recording and analyzing CPU cycles
    27. 11. Profiling Applications
    28. Example: Using perf to profile a command
    29. Example: Using strace to analyze system calls

  57. Understanding System Calls and Libraries

    1. 1. Tracing System Calls
    2. Example: Using strace to trace a command
    3. Example: Tracing a running process
    4. 2. Tracing Library Calls
    5. Example: Using ltrace to trace library calls
    6. 3. Viewing Shared Libraries
    7. Example: Using ldd to view dependencies
    8. 4. Managing Library Cache
    9. Example: Updating Library Cache
    10. 5. Setting Library Path
    11. Example: Setting Library Path Temporarily
    12. Example: Using LD_PRELOAD to Override System Library
    13. 6. Viewing Open Files
    14. Example: Using lsof to view open files for a process
    15. Example: Inspecting file descriptors via /proc
    16. 7. Finding File Descriptors
    17. Example: Viewing file descriptors for a process
    18. 8. Debugging with gdb
    19. Example: Basic gdb session
    20. 9. Analyzing Core Dumps
    21. Example: Analyzing a Core Dump with GDB
    22. 10. Using valgrind for Memory Analysis
    23. Example: Running valgrind on a simple C program

  58. Troubleshooting Common Issues

    1. 1. Diagnosing Boot Failures
    2. Example: Check boot logs for errors
    3. Boot Failure Troubleshooting Steps
    4. 2. Recovering from Kernel Panics
    5. Example: Emergency Boot via GRUB
    6. Recovery Steps Summary
    7. 3. Fixing File System Errors
    8. Example: Checking for File System Errors
    9. 4. Resolving Network Connectivity Issues
    10. Example: Testing DNS Resolution
    11. Example: Checking Firewall Rules
    12. 5. Debugging Service Failures
    13. Example: Check service status and logs
    14. Common Service Issues and Solutions
    15. 6. Investigating High CPU Usage
    16. Example: Identify top CPU-consuming processes
    17. Example: Monitor CPU usage over time
    18. 7. Diagnosing Memory Issues
    19. Example: Check memory usage with free
    20. Example: Identify memory-hungry processes with ps
    21. Memory Diagnosis Workflow
    22. 8. Resolving Disk Space Issues
    23. Example: Cleaning up old logs
    24. Example: Identifying large directories
    25. 9. Fixing Permission Problems
    26. Example: Changing Ownership of a Directory
    27. Example: Setting Read/Write Permissions
    28. 10. Debugging DNS Issues
    29. Example: Check DNS resolution for a domain
    30. Example: Test DNS resolution with ping
    31. 11. Troubleshooting SSH Access
    32. Example: Check SSH service status
    33. Example: Test SSH connection with verbose logging