Comprehensive Linux OS and Administration Guide

Introduction to Linux and Basic Components

What is Linux? * Linux is an Operating System (OS) similar to Windows or macOS. * It is open-source, meaning the source code is publicly available and completely free to use. * Application areas include servers, cloud computing, mobile devices (Android), embedded systems, and DevOps tools.
Basic Components of the Linux OS * Kernel: The core part of the operating system that communicates directly with the hardware such as the CPU, RAM, and disks. * Shell: A program that allows users to interact with the OS by typing commands. * File System: Organizes and stores data. A key tenet of Linux is that everything is treated as a file, including hardware devices. * GUI (Graphical User Interface): This is optional. Linux can utilize environments like GNOME or KDE, though it is frequently used via the terminal.

Linux Directory Structure

The Linux file system starts at the root ( $/$ ) directory. Folders beneath it serve fixed purposes:

$/$ : The root of the entire file system.
$/home$ : Contains user folders (analogous to C:\Users in Windows).
$/bin$ : Essential command binaries needed for basic operations (e.g., $ls$ , $cp$ , $mv$ ).
$/etc$ : Houses system configuration files.
$/var$ : Stores variable files, such as system logs.
$/tmp$ : Temporary files that are often cleared upon reboot.
$/usr$ : User programs and libraries.
$/root$ : The home directory specifically for the root (administrative) user.
$/dev$ : Files representing hardware devices like USB drives and hard disks.
$/proc$ : A virtual folder containing system and process information.

Basic Linux Commands and Operations

Navigation and File Management: * $pwd$ : Show current working directory. * $ls$ : List files and folders. * $cd$ : Change directory. * $mkdir$ : Create a new directory. * $touch$ : Create an empty file. * $cp$ : Copy files or folders. * $mv$ : Move or rename files and folders. * $rm$ : Delete files. * $cat$ : Display the full contents of a file. * $clear$ : Clear the terminal screen. * $exit$ : Close the current terminal or shell session.

User Permissions and Ownership

Linux is a multi-user environment where every file and folder is assigned specific permissions and ownership to ensure security and isolation.

User Types: * root: The superuser with administrative privileges and full access. * Normal users: Have limited access to the system.
Permissions Categories: * Owner: The specific user who owns the file. * Group: A collection of users with shared access. * Others: Everyone else on the system.
Permission Types: * $r$ (read): Allows viewing content. * $w$ (write): Allows modifying content. * $x$ (execute): Allows running a file or entering a directory.
Example Permission String: $-rwxr-xr--$ * The first character ( $-$ ) indicates the file type. * $rwx$ (owner): Full permissions (read, write, execute). * $r-x$ (group): Read and execute permissions only. * $r--$ (others): Read-only access.

Package Management and Software Installation

Different Linux distribution families use different package managers to install, update, and remove programs:

Ubuntu/Debian-based: Uses $apt-get install <package-name>$ or $apt$ .
Red Hat/CentOS/Fedora: Uses $yum install <package-name>$ or $dnf install$ .
Arch Linux: Uses $pacman$ .
Universal Formats: Includes $snap$ , $flatpak$ , and $AppImage$ .

CRUD Operations in Linux

CRUD stands for Create, Read, Update, and Delete. These operations can be performed on files, directories, content, and system records.

CREATE Operations: * Create a file: $touch\,filename.txt$ * Create a file with content (Option A): $echo\,"Hello, Linux!"\,>\,hello.txt$ * Create a file with content (Option B): $cat\,>\,data.txt$ (Then type content and press $Ctrl+D$ to save). * Create a directory: $mkdir\,projects$ * Create nested directories: $mkdir\,-p\,devops/scripts/yaml$
READ Operations: * View content: $cat\,filename.txt$ * Scrollable view: $less\,filename.txt$ * Page-wise output: $more\,filename.txt$ * View first $10$ lines: $head\,filename.txt$ * View last $10$ lines: $tail\,filename.txt$ * List files: $ls$ * Detailed list (permissions, size, owner): $ls\,-l$ * Show hidden files: $ls\,-a$ * Read specific line (e.g., $3^{rd}$ line): $sed\,-n\,'3p'\,filename.txt$ or $awk\,'NR==3'\,filename.txt$
UPDATE Operations: * Append to file: $echo\,"New line"\,>>\,file.txt$ * Edit via terminal: $nano\,filename.txt$ (Beginner-friendly) or $vim\,filename.txt$ (Advanced). * Replace text: $sed\,-i\,'s/oldtext/newtext/g'\,filename.txt$ * Rename/Move: $mv\,oldname.txt\,newname.txt$
DELETE Operations: * Delete file: $rm\,filename.txt$ * Delete directory: $rm\,-r\,foldername$ * Force delete: $rm\,-rf\,foldername$ * Warning: Executing $rm\,-rf\,/$ can wipe the entire operating system and should never be used lightly.

The VIM Editor – Modes and Operations

Vim (Vi IMproved) is a modal text editor essential for editing configuration files, shell scripts, and YAML files in headless server environments.

Primary Modes: 1. Normal Mode: The default mode used for navigation, deleting, and copying. (Enter by pressing $Esc$ ). 2. Insert Mode: Used for typing text. (Enter by pressing $i, I, a, A, o, or O$ ). 3. Command-Line Mode: Used for saving, quitting, and searching. (Enter by pressing $:$ from Normal Mode).
Navigation Actions (Normal Mode): * $h, j, k, l$ : Left, Down, Up, Right. * $w / b$ : Jump to next/previous word. * 0 / \: Start/End of line. * $gg / G$ : Top/Bottom of file.
Editing Actions (Normal Mode): * $dd$ : Delete (cut) line. * $yy$ : Copy (yank) line. * $p / P$ : Paste below/above cursor. * $u$ : Undo. * $Ctrl+r$ : Redo.
Command-Line Mode Utilities: * $:w$ : Save. * $:q$ : Quit. * $:wq$ or $ZZ$ : Save and quit. * $:q!$ : Force quit without saving. * $:set\,nu$ : Show line numbers. * $/word$ : Search for a word ( $n$ for next match). * $:%s/old/new/g$ : Global find and replace.

Numeric (Octal) Permissions and chmod

Permissions are calculated using numeric values based on binary logic:

$r$ (Read): $4$
$w$ (Write): $2$
$x$ (Execute): $1$

Combined values (examples):

$7$ ( $4+2+1$ ): $rwx$
$6$ ( $4+2+0$ ): $rw-$
$5$ ( $4+0+1$ ): $r-x$
$4$ ( $4+0+0$ ): $r--$

Commonly used numeric codes:

$777$ : Everyone has full access.
$755$ : Owner has full access; others can read and execute.
$700$ : Only the owner has access.
$644$ : Owner can read/write; others can only read.
$600$ : Only the owner can read/write.

Advanced Permissions and Special Bits

Special Permissions: * $s$ (Setuid / Setgid): Runs a program with the owner or group's privileges. * $t$ (Sticky Bit): Applied to directories (like $/tmp$ ) to ensure only the file owner can delete their specific files.
Directory-Specific Behavior: * $r$ : Ability to list files ( $ls$ ). * $w$ : Ability to add or remove files. * $x$ : Ability to enter the directory ( $cd$ ).

Linux User and Group Management

User Management Commands: * Create: $sudo\,adduser\,riyas$ (creates home directory and prompts for password). * Delete: $sudo\,deluser\,--remove-home\,riyas$ . * Modify: $sudo\,usermod\,-aG\,devops\,riyas$ (adds user to the 'devops' group). * Lock/Unlock: $sudo\,usermod\,-L\,riyas$ (Lock); $sudo\,usermod\,-U\,riyas$ (Unlock).
Information Files: * $/etc/passwd$ : Account details (username, UID, GID). * $/etc/shadow$ : Encrypted passwords. * $/etc/group$ : Group definitions. * $/etc/sudoers$ : Permissions for sudo access.

Service Management (systemd and systemctl)

A service (or daemon) is a background process. Modern Linux distributions use $systemd$ for management.

Service Operations: * $systemctl\,start\,nginx$ : Start service. * $systemctl\,stop\,nginx$ : Stop service. * $systemctl\,restart\,nginx$ : Restart service. * $systemctl\,status\,nginx$ : Check if service is running. * $systemctl\,enable\,nginx$ : Set service to start automatically at boot.
Logs: $journalctl\,-u\,nginx\,-f$ (Follow logs for a specific unit).
Anatomy of a .service File ( $/etc/systemd/system/myapp.service$ ): * [Unit]: Description and dependencies (e.g., $After=network.target$ ). * [Service]: Defines $ExecStart$ (path to script), $WorkingDirectory$ , $User$ , and $Restart$ policy (e.g., $always$ ). * [Install]: Defines the target (e.g., $WantedBy=multi-user.target$ ).

Process Management

Process States: * R: Running * S: Sleeping * T: Stopped * Z: Zombie (terminated but not cleaned up) * D: Uninterruptible sleep (I/O wait)
Management Tools: * $top / htop$ : Live system monitoring. * $ps\,-ef$ : Snapshot of all processes. * $kill\,-9\,<PID>$ : Forcefully stop a process. * $nice / renice$ : Set process priority ( $-20$ is highest, $19$ is lowest).

Networking and Connectivity

Tools and Commands: * $ip\,a$ : View IP addresses. * $ping$ : Test connectivity to a host. * $dig / nslookup$ : DNS troubleshooting. * $ss\,-tuln$ : View listening ports and services. * $curl / wget$ : Test HTTP requests. * $nmap$ : Port scanning.

Linux Troubleshooting Checklist

Service Status: Is the service running? ( $systemctl\,status$ )
Logs: Are there error messages in $/var/log/syslog$ or $journalctl$ ?
Ports: Is the port listening? ( $ss\,-tuln$ )
Resources: Is the disk full ( $df\,-h$ ) or memory exhausted ( $free\,-h$ )?
Permissions: Does the user have ownership and correct permissions?
Network: Can you ping the target or trace the route?

Sample Practice Exercise: File Creation and Permissions

Setup: mkdir\,devops_practice\,&&\,cd\,devops_practice.
Create: $touch\,inventory.txt$ .
Append Content: * $echo\,"Server1:\,192.168.1.1"\,>>\,inventory.txt$ * $echo\,"Server2:\,192.168.1.2"\,>>\,inventory.txt$
Edit: Use $sed\,-i\,'s/192.168.1.2/10.0.0.2/'\,inventory.txt$ to update the IP.
Secure: $chmod\,600\,inventory.txt$ (Only owner can read/write).
Cleanup: $rm\,inventory.txt$ .