📌 Key Takeaways

  • 96% of the world's top web servers run Linux — Linux is the operating system of the cloud
  • RHCSA is among the top 5 most-requested IT certifications by Indian IT employers
  • Linux shell scripting is required in 78% of DevOps and cloud job postings in India
  • RHCSA/RHCE certified professionals earn 20-30% more than non-certified peers
  • Average salary hike after Linux training: 65% (Thick Brain placement data)

Linux is the operating system that runs the internet. More than 90% of cloud servers, 96% of the world's top one million web servers, all major cloud platforms (AWS, Azure, GCP), every Kubernetes cluster, and virtually every Docker container runs on Linux. For anyone pursuing a career in cloud computing, DevOps, cybersecurity, or backend engineering, Linux administration is not optional — it is the foundational skill that everything else builds on. In 2026, Linux proficiency is the baseline qualification for any serious cloud or infrastructure role.

📊 Linux Market Snapshot — 2026

96%
World's top web servers run Linux
90%+
Cloud workloads on Linux instances
78%
DevOps jobs require shell scripting
Top 5
Most-requested IT certification in India

Why Linux is Non-Negotiable for IT Careers

When you SSH into an AWS EC2 instance, you land in a Linux shell. When you deploy a Docker container, it runs on Linux. When you configure a Kubernetes worker node, it runs on Linux. When you write Ansible playbooks, they execute on Linux targets. When you work with DevOps pipelines, build scripts, and monitoring systems — Linux is the environment.

Engineers who are uncomfortable at the Linux command line consistently hit a ceiling in their cloud and DevOps careers. The engineers who are fluent — who can navigate the filesystem, manage processes, configure networking, write shell scripts, and troubleshoot system issues confidently — are the ones who advance fastest.

💡 Linux + Cloud = Career multiplier. Linux alone gives you a solid foundation. Linux + AWS/Azure + Docker + Kubernetes = the highest salary brackets in Bangalore's tech market.

Linux Distributions: Which One to Learn?

Red Hat Enterprise Linux (RHEL) / CentOS / AlmaLinux

The enterprise Linux standard. RHEL is used across banking, insurance, telecom, government, and large IT services organisations. The RHCSA and RHCE certifications are based on RHEL. If you target IT services companies (TCS, Infosys, Wipro), system administration roles, or enterprise infrastructure — learn RHEL/CentOS/AlmaLinux.

Ubuntu

The most popular Linux distribution for cloud servers, Docker containers, and developer workstations. AWS and Azure both offer Ubuntu AMIs as default options. Ubuntu is easier to learn than RHEL due to its larger community and documentation. Ideal for developers, DevOps engineers, and cloud engineers targeting startups.

Amazon Linux

AWS's optimised Linux distribution. Built on RHEL/CentOS lineage but tuned for AWS workloads. If you work exclusively in AWS, familiarity with Amazon Linux 2023 is valuable. Core concepts transfer directly from RHEL training.

Core Linux Administration Skills

File System & Navigation

  • Linux file system hierarchy: /etc, /var, /home, /usr, /proc, /sys
  • Essential commands: ls, find, grep, awk, sed, cut, sort, wc
  • File permissions: chmod, chown, chgrp, ACLs, SUID/SGID/sticky bits
  • Hard links vs symbolic links

User & Group Management

  • Create, modify, delete users: useradd, usermod, userdel
  • Password policies, account expiry, PAM (Pluggable Authentication Modules)
  • Sudo configuration — /etc/sudoers, privilege escalation

Process & Service Management

  • Process monitoring: ps, top, htop, pgrep, kill, nice
  • Systemd: systemctl start/stop/enable/disable/status, unit files, service dependencies
  • Cron jobs and at daemon for scheduled tasks

Networking

  • Interface configuration: ip addr, nmcli, nmtui
  • Firewall: firewalld, iptables basics
  • DNS: /etc/resolv.conf, dig, nslookup, host
  • SSH: key-based authentication, sshd_config hardening

Storage & LVM

  • Disk management: fdisk, parted, filesystem creation (mkfs)
  • LVM (Logical Volume Manager): physical volumes, volume groups, logical volumes, extend/reduce
  • Mount management: /etc/fstab, mount, umount, NFS

Shell Scripting

  • Bash scripting: variables, conditionals, loops, functions, error handling
  • Text processing: grep, sed, awk for log parsing and data extraction
  • Automation scripts: backup scripts, user provisioning scripts, system health checks

Linux Learning Roadmap: 6-Stage Path

This roadmap is used in Thick Brain Technology's Linux Administration & RHCSA training program — 40 hours of live training, real RHEL labs, and full RHCSA exam preparation.

🐧
Stage 1

Linux Fundamentals

File system hierarchy, CLI basics, permissions, users, groups.

Beginner
⚙️
Stage 2

Process & Service Management

Systemd, process monitoring, cron jobs, system logging.

Beginner
🌐
Stage 3

Networking & Security

Firewalld, SSH, DNS, SELinux, firewall rules.

Intermediate
💾
Stage 4

Storage & LVM

Partitioning, LVM, filesystem creation, mounting, NFS.

Intermediate
📝
Stage 5

Shell Scripting

Bash scripting, conditionals, loops, functions, automation.

Advanced
🏆
Stage 6

RHCSA Exam Prep

Practice exams, real lab scenarios, troubleshooting.

Advanced

RHCSA Certification: Everything You Need to Know

The Red Hat Certified System Administrator (RHCSA) is the industry-standard entry-level Linux certification. Unlike multiple-choice exams, RHCSA is 100% performance-based — you solve real system administration tasks in a live RHEL environment.

Exam DetailValue
Exam Duration2.5 hours
FormatPerformance-based (hands-on in live RHEL system)
Passing Score210/300
CostUSD 400 (includes one free retake)
Validity3 years
PrerequisitesNone — 6+ months of hands-on practice recommended

RHCSA Exam Domains

  • Understand and use essential tools — 25%
  • Create simple shell scripts — 10%
  • Operate running systems — boot targets, logs, processes — 15%
  • Configure local storage — partitions, LVM, swap — 15%
  • Create and configure file systems — ACLs, NFS, autofs — 15%
  • Deploy, configure and maintain systems — repos, packages, SELinux — 20%

Top Linux Certifications 2026

These are the certifications that appear most frequently in Linux and DevOps job descriptions across Bengaluru, Hyderabad and Pune.

🏆 Most Respected
RHCSA — Red Hat Certified System Administrator
By Red Hat. 100% performance-based in a live RHEL environment. Universally recognised by Indian IT employers. The best first certification for Linux administrators.
🎯 Advanced
RHCE — Red Hat Certified Engineer
Advanced Linux certification covering automation, container management, and advanced system administration. Ideal for senior Linux engineers.
🐧 Linux Foundation
LFCS — Linux Foundation Certified Sysadmin
Vendor-neutral certification covering core Linux admin skills. Good alternative to RHCSA for non-RHEL environments.
☁️ Cloud
AWS SysOps Administrator (Linux focus)
Validates Linux admin skills in the AWS cloud — managing EC2, VPC, storage, and automation.
🎓 Practitioner
Thick Brain Linux Administration & RHCSA
40 hours live training, RHEL 9 live labs, shell scripting deep dives, full RHCSA exam preparation, and placement support until hired.

Linux Administrator Salary Guide 2026

Salary data based on Bangalore market rates, job postings, and Thick Brain placement data (2025–2026).

RoleExperienceBangalore Salary (2026)
Linux System Administrator0-2 years₹4 – 8 LPA
Senior Linux Admin (RHCSA)3-5 years₹9 – 16 LPA
Linux + Cloud Engineer3-6 years₹12 – 22 LPA
DevOps Engineer (Linux + K8s)4-8 years₹16 – 30 LPA
SRE / Platform Engineer6-10 years₹22 – 40 LPA

Source: Naukri.com, LinkedIn Jobs, Thick Brain placement data, June 2026

🚀 Ready to master Linux?

Book a free 60-minute demo class — live Linux lab, no setup needed on your end. No payment, no commitment.

100 Linux Interview Questions & Answers (2026)

The most comprehensive Linux interview question bank for Bangalore tech companies — covering file system, user management, networking, process management, shell scripting, and RHCSA preparation. Use search and category filters to focus your preparation.

Showing 100 questions
The Linux filesystem hierarchy follows the FHS (Filesystem Hierarchy Standard). Key directories: / (root), /etc (configuration files), /var (variable data like logs), /home (user home directories), /usr (user programs), /proc (process and kernel information), /sys (kernel and device information). Understanding this structure is essential for navigation and system administration.
A hard link points directly to the inode — deleting the original file does not remove the data as long as one hard link exists. A soft link (symlink) points to the file path; if the original is deleted, the symlink breaks. Hard links cannot span filesystems or link directories. In DevOps, symlinks are commonly used for versioning configuration files and managing binary installations.
chmod 755 sets file permissions to: owner (7 = rwx), group (5 = r-x), others (5 = r-x). This is a common permission for executable scripts and directories. For security-sensitive files, use 600 (rw-------). Use 644 for regular files (rw-r--r--).
Use find /path -type f -size +100M. For human-readable output: find /path -type f -size +100M -exec ls -lh {} \;. This is useful for identifying disk space hogs, rotating logs, or cleaning up storage.
grep: search for patterns — grep -r "ERROR" /var/log/. awk: field-based processing — awk '{print $1, $9}' /var/log/nginx/access.log extracts IP and status code. sed: stream editing — sed -i 's/old_value/new_value/g' config.env. All three are essential for log parsing and configuration management.
/etc/fstab defines how filesystems are mounted at boot time. Each entry includes: device/UUID, mount point, filesystem type, mount options, dump flag, and fsck order. If an entry is wrong, the system may fail to boot. Always test new entries with mount -a before rebooting.
cp copies files; mv moves/renames files; rm removes (deletes) files. Use cp -r for recursive copying, mv -i to prompt before overwriting, and rm -rf with extreme caution (deletes recursively without confirmation). Always backup before rm in production.
/proc is a virtual filesystem that provides runtime system information. It contains: /proc/cpuinfo (CPU details), /proc/meminfo (memory usage), /proc/uptime (system uptime), and per-process directories (/proc/PID/). Monitoring tools like top and ps read from /proc.
Edit crontab: crontab -e. Add: */5 * * * * /path/to/script.sh. For production, redirect output: */5 * * * * /path/to/script.sh >> /var/log/script.log 2>&1. Systemd timers are a modern alternative to cron.
/var/log stores system and application log files. Important logs: /var/log/messages (general system logs), /var/log/secure (authentication logs), /var/log/maillog (mail server logs), /var/log/audit/ (audit logs). Log rotation is managed by logrotate to prevent disk exhaustion.
Create user: useradd john. Set password: passwd john. For automatic password setting: echo "password" | passwd --stdin john. To create a home directory: useradd -m john. To create with custom UID: useradd -u 2000 john. User accounts are stored in /etc/passwd and encrypted passwords in /etc/shadow.
/etc/sudoers defines which users can run which commands with sudo. Always edit with visudo — it validates syntax before saving. Example: john ALL=(ALL) ALL gives full sudo access. For restricted access: john ALL=(ALL) /usr/bin/systemctl restart nginx. Never edit /etc/sudoers directly.
Use usermod: usermod -g new_primary_group john (change primary group), usermod -aG supplementary_group1,supplementary_group2 john (add to supplementary groups). Changes take effect on next login. Verify with groups john.
/etc/passwd stores user account information (UID, GID, home directory, shell) — world-readable. /etc/shadow stores encrypted passwords and password expiry information — readable only by root. The separation improves security by keeping hashed passwords out of world-readable files.
Two methods: (1) usermod -L john (locks password by adding '!' to shadow file). (2) passwd -l john. To unlock: usermod -U john or passwd -u john. For temporary accounts, lock instead of delete.
Use chage: chage -M 90 john (max days until password expires), chage -W 7 john (warn 7 days before expiry), chage -I 30 john (inactivity lock after 30 days). To view current settings: chage -l john. Default policies are set in /etc/login.defs.
PAM provides a modular authentication framework. It allows you to configure authentication for different services (login, sudo, SSH) independently. PAM configuration files are in /etc/pam.d/. Common modules: pam_unix.so (standard Unix auth), pam_ldap.so (LDAP integration).
Use userdel -r john (deletes user and home directory). Without -r, the home directory remains. Backup important files before deletion. For archived users, lock the account instead of deleting.
/etc/group stores group information: group name, GID, and member list. Use groups john to list a user's group memberships. To add a user to a group: usermod -aG groupname john. Group memberships affect file permissions.
In /etc/ssh/sshd_config, set DenyUsers john or DenyGroups restricted. Restart SSH: systemctl restart sshd. For more granular control, use Match User john with ForceCommand /bin/false.
A process is an independent execution unit with its own memory space, file descriptors, and PID. A thread shares memory and resources with other threads in the same process. Both are created via the clone() syscall — threads use CLONE_THREAD flags. In DevOps this matters when sizing container resource limits and diagnosing high-concurrency issues in microservices.
Use ls -l /proc/<PID>/fd to list all open file descriptors, or lsof -p <PID> for a human-readable view. lsof -u username shows all FDs for a user. Production servers hitting the ulimit -n limit (default 1024) cause "too many open files" errors — increase it in /etc/security/limits.conf.
systemd is a modern init system and service manager for Linux. Unlike the traditional SysV init which starts services sequentially via shell scripts, systemd starts services in parallel using dependency graphs, dramatically reducing boot time. Key commands: systemctl start/stop/enable/status servicename. systemd also manages logging via journalctl, replacing syslog.
Run top or htop to identify the process consuming CPU. Use ps aux --sort=-%cpu | head -10 for a snapshot. Drill down with strace -p <PID> to trace syscalls, or perf top for kernel-level profiling. In Kubernetes, check pod CPU with kubectl top pods. Common causes: runaway loops, high GC pressure, or resource limits set too low.
kill <PID> sends SIGTERM (signal 15) — a graceful shutdown request the process can catch, handle, and clean up before exiting. kill -9 <PID> sends SIGKILL — the kernel immediately terminates the process with no cleanup. Always try SIGTERM first; use SIGKILL only if the process is unresponsive. In Kubernetes, pod termination sends SIGTERM, waits terminationGracePeriodSeconds, then sends SIGKILL.
Use ss -tlnp | grep :8080 (preferred, fast) or netstat -tlnp | grep :8080. lsof -i :8080 shows the process name and PID. On modern systems, ss from the iproute2 package replaces netstat. This is essential when a service fails to start with "address already in use" — identify and stop the conflicting process.
ulimit controls per-process resource limits set by the kernel. Critical limits: nofile (open file descriptors), nproc (max processes), memlock (locked memory, required by Elasticsearch). Default nofile of 1024 causes failures in production databases and Nginx under load. Set persistent limits in /etc/security/limits.conf or per-service in systemd unit files via LimitNOFILE=65535.
Edit cron jobs with crontab -e. The five fields are: minute hour day-of-month month day-of-week. */5 * * * * means "run every 5 minutes." 0 2 * * 1 means "every Monday at 2:00 AM." For production, prefer systemd timers over cron — they log output to journald, support dependencies, and handle missed runs.
top is a real-time process viewer; htop is an interactive, user-friendly alternative with scrolling and mouse support; ps is a snapshot of current processes. Use ps aux for a detailed snapshot, htop for interactive monitoring, and top for quick system health checks.
A systemd unit file defines a service, mount, timer, or socket. Example for a custom service: [Unit] Description=My Service After=network.target [Service] ExecStart=/usr/bin/myservice Restart=always [Install] WantedBy=multi-user.target. Save as /etc/systemd/system/myservice.service, then systemctl daemon-reload, systemctl start myservice.
On RHEL-based systems, use nmcli or edit /etc/sysconfig/network-scripts/ifcfg-eth0. Example: TYPE=Ethernet BOOTPROTO=static IPADDR=192.168.1.100 NETMASK=255.255.255.0 GATEWAY=192.168.1.1 DNS1=8.8.8.8. On Ubuntu, edit /etc/netplan/01-netcfg.yaml. Restart networking: systemctl restart networking.
Use netstat -tuln or ss -tuln to list listening ports. nmap -sS -p- localhost scans all ports. For remote scanning: nmap -sS -p- 192.168.1.100. Check firewalld or iptables to see which ports are allowed.
SELinux (Security-Enhanced Linux) is a mandatory access control (MAC) system. Check status: getenforce (Enforcing, Permissive, Disabled). View mode: sestatus. Temporarily set to permissive: setenforce 0. For troubleshooting: audit2why, sealert. SELinux is critical for production security.
firewall-cmd --add-port=8080/tcp --permanent (add port), firewall-cmd --reload (apply). Add service: firewall-cmd --add-service=http --permanent. List rules: firewall-cmd --list-all. Firewalld is the default on RHEL/CentOS.
firewalld is a higher-level abstraction over iptables. It supports dynamic zones and services. iptables is the underlying kernel-based firewall framework. firewalld is easier to use and recommended for most systems; iptables is more flexible but complex.
Generate a key pair: ssh-keygen -t ed25519 -C "deploy-key". Copy the public key to the target: ssh-copy-id user@target-host. Test: ssh -i ~/.ssh/id_ed25519 user@target-host. In CI/CD pipelines, store the private key as a Jenkins credential or GitHub secret. Use ed25519 over RSA-2048 — it is faster and more secure.
/etc/resolv.conf defines DNS resolver settings: nameserver IPs, search domains, and options. Example: nameserver 8.8.8.8 nameserver 8.8.4.4 search example.com. On modern systems, systemd-resolved may manage it. DNS resolution issues often start here.
Use dig example.com (verbose DNS query), nslookup example.com (simple), host example.com (quick). Check /etc/resolv.conf for correct nameservers. Use ping example.com to test connectivity. For systemd-resolved: systemd-resolve --status.
In /etc/ssh/sshd_config: set PermitRootLogin no, PasswordAuthentication no, PubkeyAuthentication yes, AllowUsers user1 user2, MaxAuthTries 3, ClientAliveInterval 300. Restart SSH: systemctl restart sshd. Always use SSH keys over passwords.
TCP wrappers (libwrap) provide host-based access control. Configure via /etc/hosts.allow and /etc/hosts.deny. Example: sshd: 192.168.1.0/24 in hosts.allow. Modern services use firewalld instead. Deprecated in many distributions.
Use fdisk /dev/sdb (interactive) or parted. Create partition, set type, write. Then format: mkfs.ext4 /dev/sdb1 (ext4), mkfs.xfs /dev/sdb1 (XFS). Mount: mount /dev/sdb1 /mnt/data. Add to /etc/fstab for persistence.
LVM (Logical Volume Manager) provides flexible disk management. Steps: pvcreate /dev/sdb (create PV), vgcreate vg_data /dev/sdb (create VG), lvcreate -L 10G -n lv_data vg_data (create LV). Format LV: mkfs.ext4 /dev/vg_data/lv_data. Mount: mount /dev/vg_data/lv_data /mnt/data.
Add a new disk: pvcreate /dev/sdc, vgextend vg_data /dev/sdc. Extend LV: lvextend -L +10G /dev/vg_data/lv_data. Resize filesystem: resize2fs /dev/vg_data/lv_data (ext4) or xfs_growfs /mnt/data (XFS). No data loss.
ext4 — reliable, good for general purpose, supports online defragmentation. XFS — high performance for large files, better with parallel I/O. XFS is the default on RHEL 9. Both are journaled. Use ext4 for general workloads; XFS for large filesystems and databases.
On server: yum install nfs-utils, create exported directory, edit /etc/exports: /shared 192.168.1.0/24(rw,sync). Start NFS: systemctl start nfs-server. On client: mount -t nfs server:/shared /mnt/client. Add to /etc/fstab for auto-mount.
/etc/fstab is the static filesystem table that defines which filesystems mount at boot. /etc/mtab lists currently mounted filesystems (dynamic, updated by the kernel). On modern systems, /proc/mounts is the definitive source for mounted filesystems.
Create swap file: dd if=/dev/zero of=/swapfile bs=1M count=2048 (2GB). Set permissions: chmod 600 /swapfile. Format: mkswap /swapfile. Enable: swapon /swapfile. Add to /etc/fstab: /swapfile none swap defaults 0 0. Use swap for low-memory systems.
df -h shows disk usage by filesystem. du -sh /* 2>/dev/null | sort -rh | head -20 finds the largest directories. find / -type f -size +1G 2>/dev/null locates files over 1 GB. Watch for growing log files and core dumps.
fsck checks and repairs filesystem inconsistencies. Run it on unmounted filesystems: umount /dev/sdb1, fsck /dev/sdb1. It runs automatically on boot if the filesystem is unclean. Use fsck -y to auto-repair errors.
Full backup: tar -czvf backup.tar.gz /path/to/backup. Incremental backup: tar -czvf backup_inc.tar.gz --listed-incremental=snapshot.file /path/to/backup. Restore: tar -xzvf backup.tar.gz. For large filesystems, use rsync or dedicated backup tools.
Use $1, $2, etc. Example: #!/bin/bash echo "Hello, $1". Run: ./script.sh John. Use $@ for all arguments, $# for argument count. For named arguments, use getopts.
Basic if: if [ "$1" == "hello" ]; then echo "Hello"; else echo "Not hello"; fi. File checks: -f (file exists), -d (directory), -x (executable). Numeric comparisons: -eq, -ne, -lt, -gt.
For loop: for i in {1..5}; do echo $i; done. While loop: while [ $count -lt 10 ]; do echo $count; ((count++)); done. Until loop: until [ $count -ge 10 ]; do echo $count; ((count++)); done. Use loops for iterating over files or command output.
Use command substitution: output=$(command) or output=`command`. Example: current_date=$(date). Then use echo $output. For multi-line output, use quotes: echo "$output".
set -e makes the script exit immediately if any command returns a non-zero exit status. set -u treats unset variables as errors and exits. Use these for production scripts to ensure reliability and prevent silent failures.
Function definition: my_function() { echo "Hello from function"; }. Call: my_function. Functions can accept arguments: print_args() { echo "First: $1"; }. Functions must be defined before they are called.
Check exit status: if ! command; then echo "Error"; exit 1; fi. Use trap to catch signals: trap 'echo "Script interrupted"; exit 1' INT TERM. Use set -e for automatic exit on error. Always log errors.
Use awk or cut: awk -F, '{print $1, $3}' data.csv. For complex CSV with quotes, use csvtool or python. Bash is not ideal for complex CSV parsing; consider Python for production.
Create a service file: /etc/systemd/system/myscript.service with ExecStart=/path/to/script.sh. Create a timer file: /etc/systemd/system/myscript.timer with OnCalendar=*-*-* 00:00:00. Enable: systemctl enable --now myscript.timer. systemd timers are more reliable than cron.
Run with bash -x script.sh to see each command executed. Use set -x inside the script for selective debugging. Add echo statements. Use shellcheck for static analysis. Log outputs to a file for later review.
1. Understand and use essential tools (25%). 2. Create simple shell scripts (10%). 3. Operate running systems (15%). 4. Configure local storage (15%). 5. Create and configure file systems (15%). 6. Deploy, configure and maintain systems (20%). The exam is 100% performance-based.
(1) Use a RHEL 9 VM for daily practice. (2) Complete the Red Hat RHCSA training (official or Thick Brain). (3) Practice real tasks: user management, LVM, firewalld, SELinux, shell scripting. (4) Use practice exams. (5) Review exam objectives. Thick Brain's Linux course includes full RHCSA preparation.
RHCSA is the entry-level certification covering essential system administration. RHCE (Red Hat Certified Engineer) is an advanced certification covering automation, container management, and complex system administration. RHCSA is a prerequisite for RHCE. Most engineers start with RHCSA.
Check SELinux audit logs: ausearch -m avc. Use audit2why to understand the denial. For quick fixes: chcon (change context) or semanage fcontext (set default context). Use setsebool to adjust SELinux booleans. Temporarily set permissive mode for testing: setenforce 0.
Use sysctl for runtime changes: sysctl vm.swappiness=10. To persist: edit /etc/sysctl.conf or add files to /etc/sysctl.d/. Apply: sysctl -p. Common parameters: net.ipv4.tcp_fin_timeout, fs.file-max.
Create a directory with RPMs. Create repo config: [local] name=Local Repository baseurl=file:///path/to/repo enabled=1 gpgcheck=0. Save as /etc/yum.repos.d/local.repo. Run yum makecache. Use for offline environments.
Edit /etc/logrotate.conf or add custom configs in /etc/logrotate.d/. Example: /var/log/nginx/*.log { weekly rotate 5 compress delaycompress missingok }. Run manually: logrotate -f /etc/logrotate.conf.
/etc/profile is system-wide, runs for all users on login shells. ~/.bashrc runs for interactive non-login shells (terminal windows). For environment variables, use /etc/profile.d/. For aliases, add to ~/.bashrc.
Use hostnamectl set-hostname newhostname. For RHEL/CentOS, also edit /etc/hosts and /etc/hostname. Reboot recommended. Verify: hostnamectl status.
Use who -b (last boot time), uptime -s (system start time), systemd-analyze (boot time breakdown), journalctl --list-boots (list boot logs).
1. BIOS/UEFI initialises hardware and finds boot loader. 2. GRUB loads and selects kernel. 3. Kernel loads, initialises drivers, mounts root filesystem. 4. systemd (PID 1) starts services and targets. 5. Login manager or shell prompt appears.
Boot from rescue media or single-user mode. Check journalctl -b for boot logs. Verify /etc/fstab for corrupt entries. Check disk health: smartctl. Use fsck on root filesystem. Repair GRUB if needed.
This directory contains network interface configuration files (e.g., ifcfg-eth0). Each file defines IP address, gateway, DNS, and boot protocol. On newer versions, nmcli and nmtui are preferred for network management.
A kernel panic is a fatal error from which the kernel cannot recover. Diagnose by looking at console output or /var/log/kern.log (or journalctl -k). Common causes: hardware failure, bad driver, corrupted kernel module. Use kexec to load a known good kernel.
Use top, htop (CPU/memory), iostat (disk I/O), vmstat (memory and CPU), netstat (network), strace (syscalls), perf (CPU profiling). For long-term monitoring, use sar or prometheus.
Immediately unmount the filesystem (umount). Use testdisk or extundelete for ext4, xfs_undelete for XFS. Recovery is not guaranteed — prevention is better. Use backups and rm -i or trash-cli.
Runlevels: 0 (halt), 1 (single user), 2 (multi-user), 3 (multi-user + network), 4 (unused), 5 (graphical), 6 (reboot). Check: runlevel. Change: systemctl set-default runlevel5.target. With systemd, runlevels are mapped to targets: multi-user.target (runlevel 3), graphical.target (runlevel 5).
A zombie process is a terminated process still in the process table waiting for its parent to collect its exit status. It cannot be killed with kill. The only solution is to kill the parent process (which will adopt and wait for zombies).
strace traces system calls and signals made by a process. Example: strace -p 1234 (trace PID 1234). Use -e trace=open,read,write to filter. Essential for debugging application behaviour and permission issues.
Use journalctl -u servicename.service. For real-time: journalctl -f -u servicename.service. To see logs since last boot: journalctl -b. To filter by priority: journalctl -p err.
Most EC2 instances run Linux (Amazon Linux, Ubuntu, RHEL). You SSH into them, manage with Bash, configure services with systemd, and set up security groups. Linux skills are essential for EC2 operations.
Launch EC2 with a key pair. Use ssh -i key.pem ec2-user@public-ip (Amazon Linux) or ubuntu@public-ip (Ubuntu). Ensure security group allows SSH from your IP.
Amazon Linux is AWS's optimised Linux distribution based on RHEL/CentOS but with AWS-specific tools and kernel optimisations. It is the default on many EC2 instances. Commands and configuration are similar to RHEL but some packages differ.
User data is a script that runs when the instance launches. Example: #!/bin/bash yum update -y yum install httpd -y systemctl start httpd. Use cloud-init for more complex setup. Valid for both Amazon Linux and Ubuntu.
Linux containers isolate processes using namespaces and cgroups. Docker is a container runtime that packages applications as images and runs them using Linux containers. Docker uses the host's Linux kernel. Containers are lightweight compared to VMs.
Use SSH for direct access. If SSH fails, use cloud provider's console (AWS EC2 Instance Connect, Azure Serial Console). Check cloud-init logs (/var/log/cloud-init-output.log). Use systemctl and journalctl for service logs.
Linux is the foundation of DevOps. CI/CD runners run on Linux, containers (Docker/Kubernetes) run on Linux, configuration management (Ansible, Chef) targets Linux systems. Almost every DevOps tool is built for Linux first.
Launch a small Linux instance in a public subnet, with a security group that allows SSH from your IP. Place other instances in private subnets. SSH into the bastion first, then SSH from bastion to private instances.
Install prometheus_node_exporter on Linux to expose metrics to Prometheus. Use top, iostat, netstat, ss for real-time monitoring. Use logwatch and auditd for log analysis.
Use rsync to copy data, then launch an EC2 instance and configure it. Use AWS Application Migration Service (MGN) for server migration. Ensure Linux versions match.
ssh provides a secure interactive shell session. scp uses SSH to securely copy files between systems. Example: scp file.txt user@server:/path/. For large transfers, use rsync.
Use pkill or killall. Example: pkill nginx kills all processes named nginx. Use pkill -f "full command" for more precision. Confirm with pgrep.
/etc/issue contains the pre-login welcome message displayed before the login prompt. It can be customised for security or branding. /etc/issue.net is for SSH connections.
Use uname -r (kernel release), uname -a (all system info). cat /proc/version also shows kernel version and build details.
Set default target: systemctl set-default multi-user.target (runlevel 3) or systemctl set-default graphical.target (runlevel 5). Verify: systemctl get-default.
Static IP is manually configured and does not change. Dynamic IP is assigned by DHCP and may change on reboot. Servers use static IPs. Desktop machines often use DHCP.
Use timedatectl set-timezone Asia/Kolkata. Check current timezone: timedatectl show --property Timezone --value. For older systems, link to /etc/localtime.
Download source, extract, then: ./configure, make, make install. Dependencies must be installed first. Use package managers (yum, apt) whenever possible.
It sets per-user resource limits (nofile, nproc, stack). Example: * soft nofile 65535. Applies to PAM modules. systemd services use LimitNOFILE instead.
Thick Brain Technology's Linux Administration & RHCSA course includes comprehensive interview preparation: (1) 40 hours of live training with RHEL 9 labs. (2) Shell scripting deep dives. (3) Full RHCSA exam preparation. (4) Mock interview sessions. (5) Placement support until hired. Book a free demo to start your Linux journey.

Frequently Asked Questions

RHCSA (Red Hat Certified System Administrator) is a performance-based Linux certification. You solve real sysadmin tasks in a live RHEL environment over 2.5 hours — no multiple choice. It is universally recognised by Indian IT employers and validates that you can actually administer Linux systems, not just answer questions about them.
A structured 40-50 hour Linux administration training course covers the essentials in 5-7 weeks. Daily hands-on practice in a Linux environment (a free VM on your own laptop works fine) is critical. With consistent practice, most students are ready to attempt the RHCSA exam within 3 months of starting structured training.
Yes — absolutely. AWS EC2, Azure VMs, and virtually all cloud compute instances run Linux. You will be managing, configuring, troubleshooting, and scripting on Linux systems daily in any cloud role. Cloud certifications assume you can work on a Linux command line. Strong Linux skills consistently differentiate candidates in cloud and DevOps interviews.
Thick Brain Technology offers comprehensive live online Linux Administration & RHCSA training — 40 hours of instructor-led training, RHEL 9 live labs, shell scripting deep dives, and full RHCSA exam preparation with placement support. Book a free demo to start your Linux journey.

Conclusion: Master Linux in 2026

Linux is the foundation of the modern cloud. Whether your goal is DevOps, cloud engineering, cybersecurity, or site reliability engineering, you will use Linux every day. Investing in Linux administration skills — and validating them with the RHCSA certification — is one of the highest-return investments you can make early in your IT career.

The market rewards engineers with strong Linux fundamentals. Combined with cloud and DevOps skills, Linux proficiency opens doors to the highest salary brackets in Bangalore's tech market.

Thick Brain Technology's Linux Administration & RHCSA Training covers RHEL 9 with real lab environments, shell scripting deep dives, and full RHCSA exam preparation. Classes are available online in evening and weekend batches. Book a free demo class to start your Linux journey.

🐧

Master Linux with Real RHEL Labs

Book a free demo class and start your Linux journey with live labs. No payment required.

Share this article