DEV Community: Sheikh Hassaan Bin Nadeem

How to Take Remote Backups Using rsync Over SSH (Day 12 of 30)

Sheikh Hassaan Bin Nadeem — Mon, 05 May 2025 22:25:38 +0000

Introduction
Why Organizations Still Use rsync
Understanding rsync and SSH
Step-by-Step Guide to Remote Backups
Real-World Use Case
Summary

1. Introduction

Backups are essential for any system administrator. While many organizations invest in commercial backup solutions like Veritas NetBackup, Veeam, or Windows NT Backup, there's a simpler, open-source tool that's been trusted for years: rsync.

In this article, we'll explore how to use rsync over SSH to perform remote backups efficiently and securely.

2. Why Organizations Still Use rsync

Despite the availability of commercial tools, many organizations prefer rsync because:

Simplicity: Easy to set up and use.
Efficiency: Transfers only changed files, saving bandwidth and time.
Security: Works seamlessly over SSH for encrypted transfers.
Flexibility: Suitable for various backup scenarios, from small directories to entire systems.

3. Understanding rsync and SSH

rsync is a command-line utility that synchronizes files and directories between two locations. When combined with SSH, it allows secure data transfer over networks.

Basic Syntax:

rsync [options] [source] [user@remote_host:destination]

Common Options:

-a: Archive mode (preserves permissions, timestamps, symbolic links, etc.)
-v: Verbose output
-z: Compress data during transfer
-e ssh: Use SSH for data transfer

4. Step-by-Step Guide to Remote Backups

Step 1: Ensure rsync is Installed

On most Linux systems, rsync is pre-installed. To check:

rsync --version

If not installed, you can install it using your package manager:

For Red hat/CentOS:

  sudo yum install rsync

For Debian/Ubuntu:

  sudo apt-get install rsync

Step 2: Perform the Backup

To back up a directory from a remote server to your local machine:

rsync -avz -e ssh user@remote_host:/path/to/remote/directory /path/to/local/destination

Example:

rsync -avz -e ssh user@192.168.1.100:/var/www/html /home/user/backup/html

This command will:

Connect to remote_host as user.
Synchronize the /var/www/html directory from the remote server to /home/user/backup/html on the local machine.
Preserve file permissions, timestamps, and compress data during transfer.

5. Real-World Use Case

Imagine you're managing a web server hosted on AWS, and you want to back up the website files to your local machine daily.

Step 1: Set Up SSH Access

Ensure you can SSH into the remote server:

ssh user@192.168.1.100

Step 2: Create a Backup Script

Create a script named backup.sh:

#!/bin/bash
rsync -avz -e ssh user@192.168.1.100:/var/www/html /home/user/backup/html

Make the script executable:

chmod +x backup.sh

Step 3: Schedule the Backup

Use cron to schedule the backup daily at 2 AM:

0 2 * * * /path/to/backup.sh

This setup ensures that your website files are backed up daily without manual intervention.

6. Summary

While commercial backup solutions offer advanced features, rsync remains a reliable and efficient tool for many organizations. Its simplicity, combined with the security of SSH, makes it an excellent choice for remote backups.

By following the steps outlined above, you can set up automated, secure backups for your systems, ensuring data integrity and peace of mind.

Connect with me on LinkedIn: https://linkedin.com/comm/mynetwork/discovery-see-all?usecase=PEOPLE_FOLLOWS&followMember=sheikhhassaanbinnadeem

Access Control Lists in Linux for Granular Permissions (Day 11 of 30)

Sheikh Hassaan Bin Nadeem — Sun, 04 May 2025 22:35:01 +0000

Introduction
Why Traditional Permissions Fall Short
What Are ACLs and When to Use Them
Basic ACL Commands: getfacl and setfacl
Real-World Examples
Removing and Managing ACLs
Best Practices
Summary

1. Introduction

In Linux, we usually use chmod and chown to manage file permissions. That works well when you just need to give access to one user and one group. But what if you need to give access to multiple users or different groups on the same file?

That's where ACLs (Access Control Lists) come in. They allow you to control file access in a much more detailed way.

2. Why Traditional Permissions Fall Short

Standard permissions only allow:

One owner (user)
One group

Let’s say you want to:

Give read-only access to one user
Allow full access to another user
And block a group from accessing the file

You can’t do this with just chmod.

ACLs solve this problem easily.

3. What Are ACLs and When to Use Them

ACL stands for Access Control List. It gives you the ability to assign file permissions to multiple users or groups not just the owner and one group.

When should you use ACLs?

When files need to be shared between many users
When group permissions are not enough
In team or project folders with different roles

4. Basic ACL Commands: `getfacl` and `setfacl`

Here are the two main commands:

Check current ACLs

getfacl filename

Give read permission to a user

setfacl -m u:john:r-- filename

Give write access to a group

setfacl -m g:developers:rw- filename

Set default ACLs on a directory (for new files)

setfacl -d -m u:john:r-- /project-folder

This means every new file in /project-folder will automatically give john read access.

5. Real-World Examples

Example 1: Give read access to `alice` on a log file

setfacl -m u:alice:r-- /var/log/custom.log

Example 2: Block write access for group `interns`

setfacl -m g:interns:r-- /project/data.txt

Example 3: Make sure all new files in a folder are readable by user `sam`

setfacl -d -m u:sam:r-- /reports

6. Removing and Managing ACLs

Remove specific ACL entry

setfacl -x u:john filename

Remove all ACLs and go back to normal permissions

setfacl -b filename

This is useful if you want to reset everything.

7. Best Practices

Use ACLs only when standard permissions are not enough
Keep it simple, don’t overuse ACLs
Document special permissions so your team knows who has access
Use getfacl regularly to check what’s set

8. Summary

ACLs help you give very specific permissions to different users or groups. They're great when you need more control than chmod or chown can offer.

If you’re working in teams or managing shared files, knowing ACLs is a very useful skill.

Try them out and remember, Linux gives you the tools. It’s up to you to use them wisely.

Understanding /etc/passwd – Linux User Account Properties (Day 10 of 30)

Sheikh Hassaan Bin Nadeem — Wed, 30 Apr 2025 21:03:02 +0000

Introduction
Why Understanding User Account Properties Matters
The /etc/passwd File – A Goldmine of User Info
Breaking Down Key Fields
How to View and Interpret User Info
Summary

1. Introduction

Every time you log in, run a command, or access a file on a Linux system, you're doing it as a user. But have you ever stopped to ask: what exactly defines a user? How does Linux know what you’re allowed to do?

This is where user account properties come into play. Hidden in plain sight, they’re the DNA of user identity in Linux and knowing them is essential not just for RHCSA exams but also for real-world DevOps, cloud, and sysadmin roles.

2. Why Understanding User Account Properties Matters

Many beginners (and even intermediate users) overlook these properties because they appear technical or cryptic. But here’s the truth:

Misunderstanding UID or GID can lead to permission issues that break deployments.
Failing to grasp default shells or home directories can create confusion in automation scripts or multi-user environments.
Businesses care about access control, auditing, and traceability. If you can’t explain what a user ID represents or how it maps to a file ownership, you’re not production-ready.

So this isn’t just about passing an exam. It’s about making smarter, more secure decisions in the real world.

3. The `/etc/passwd` File – A Goldmine of User Info

Linux stores core user account information in a plain text file called /etc/passwd.

To view it:

cat /etc/passwd

Each line in this file represents a single user and looks like this:

hassan:x:1001:1001:Hassan Bin Nadeem:/home/hassan:/bin/bash

Let’s break this down in the next section.

4. Breaking Down Key Fields

Each line in /etc/passwd has 7 colon-separated fields, and understanding them makes the whole system clearer:

Field Number	Field Name	Example Value	Description
1	Username	`hassan`	Login name of the user.
2	Password (Placeholder)	`x`	Indicates that the actual password is stored in `/etc/shadow`.
3	User ID (UID)	`1001`	Unique ID assigned to the user. System users typically have UIDs below 1000.
4	Group ID (GID)	`1001`	Primary group the user belongs to.
5	User Info / Comment	`Hassan Bin Nadeem`	Sometimes used to describe the full name or purpose of the account.
6	Home Directory	`/home/hassan`	Default working directory after login.
7	Login Shell	`/bin/bash`	The shell that launches upon login.

Harder Way: You can manually memorize all these field positions...

Smarter Way: Just understand the logic. Once you grasp what Linux needs to know about a user, the fields naturally make sense.

5. How to View and Interpret User Info

Let’s look at how you can check user details using commands that are easy to remember:

View All Usernames

grep '/home' /etc/passwd

This filters out real users (not system accounts) by matching entries that have home directories.

View UID and GID for a User

id hassan

This shows the user ID, group ID, and all groups the user belongs to.

See Default Shell for a User

grep hassan /etc/passwd

This prints the full line, and you can easily read the shell at the end.

6. Summary

By exploring the /etc/passwd file, you can:

Identify how Linux defines a user
Understand permissions through UID and GID
Troubleshoot login or shell issues
Build more secure and stable systems

Practice reading user entries as a habit. Once you’re fluent, interpreting user account data becomes effortless and insightful, like reading a name tag on a very organized team.

Understanding Linux File Permissions - The Smarter Way (Day 9 of 30)

Sheikh Hassaan Bin Nadeem — Mon, 28 Apr 2025 21:47:16 +0000

Introduction
Understanding File Permissions in Linux
The Symbolic Method (The Harder Way)
The Numeric Method (The Smarter Way)
Real-World Examples to Practice
Summary

1. Introduction

Permissions are at the heart of Linux security and daily operations. Understanding how to manage them quickly and correctly is vital whether you’re administering servers, developing apps, or just maintaining your system.

We'll explore both ways of managing permissions; the symbolic way and the numeric way but with a clear recommendation on which method to stick with for faster, smarter workflow.

2. Understanding File Permissions in Linux

Every file and directory in Linux has associated permissions that determine who can read, write, or execute them. These permissions are divided among three categories:

User (owner)
Group (users in the file’s group)
Others (everyone else)

The basic permissions are:

r (read)
w (write)
x (execute)

Mastering permission management allows you to control access and secure your systems effectively.

3. The Symbolic Method (The Harder Way)

In the symbolic method, you use letters to represent users and actions. It's very descriptive but can be slightly more tedious, especially under pressure.

Here’s the basic structure:

chmod [user][operator][permission] filename

Users: u (user), g (group), o (others), a (all)
Operators: + (add), - (remove), = (set exact permissions)

Examples:

chmod u+x file.txt   # Add execute permission for user
chmod go-w file.txt  # Remove write permission for group and others
chmod a=r file.txt   # Set read-only for everyone

While useful, this method requires you to think a little more, especially in more complex scenarios.

4. The Numeric Method (The Smarter Way)

The numeric method uses numbers to represent permissions. It’s faster, easier, and highly recommended for real-world use.

Each permission is assigned a value:

r = 4
w = 2
x = 1

You add up the numbers for each category (User, Group, Others).

Example Calculation:

Read (4) + Write (2) + Execute (1) = 7
Read (4) + Execute (1) = 5
Read (4) = 4

Example Command:

chmod 754 file.txt

Meaning:

User: 7 (read+write+execute)
Group: 5 (read+execute)
Others: 4 (read)

Quick reference table:

Permission	Value
---	0
--x	1
-w-	2
-wx	3
r--	4
r-x	5
rw-	6
rwx	7

Once you get the hang of this, you'll change permissions confidently and quickly without second-guessing!

5. Real-World Examples to Practice

✅ Make a script executable by everyone:

chmod 755 script.sh

✅ Secure a private SSH key:

chmod 600 id_rsa

✅ Make a public file readable but not writable or executable:

chmod 644 public.txt

✅ Grant full access to a user but only read access to others:

chmod 744 filename

✅ Make a directory accessible to everyone:

chmod 755 /var/www/html

These examples are directly applicable whether you’re working on Red Hat Enterprise Linux (RHEL 9) or similar distributions.

6. Summary

Both symbolic and numeric methods exist for changing permissions.
Focus primarily on the numeric method for speed and simplicity.
Keep the symbolic method at the back of your mind for when it's needed.
Always set permissions thoughtfully to maintain security!

Getting comfortable with Linux permissions is a superpower, it saves you time, protects your systems, and builds your confidence on the terminal.

Control Firewall, OpenSSH & Other System Services with systemctl (Day 8 of 30)

Sheikh Hassaan Bin Nadeem — Sun, 27 Apr 2025 15:42:24 +0000

Introduction
Understanding systemctl
- Basic operations (start, stop, status, enable, disable, restart, reload)
- Advanced operations (mask, unmask)
Practical Examples
- Examples using common services like sshd, firewalld, httpd
Summary

1. Introduction

Managing system services is a core responsibility for any Linux sysadmin or power user. On RHEL 9, which uses systemd as its init system, the systemctl command is your gateway to starting, stopping, and configuring services (daemons). Learning a few essential systemctl commands will let you control services easily—whether you're running a web server, SSH daemon, or the firewall. In this article, we’ll cover the basics of systemctl for RHEL 9 (most of it works the same on other modern distros). By the end, you’ll know how to start/stop services, enable them at boot, check their status, and even disable them if needed. Let’s dive in and get you feeling confident managing your system’s services!

2. Understanding systemctl

systemctl is the main command-line tool to interact with systemd (the service manager on RHEL 9). It can start or stop services immediately, query their status, and configure whether they run at boot. Here are the basic systemctl operations you’ll use every day:

systemctl start <service> — Start the specified service right now. For example, systemctl start sshd will launch the SSH server.
systemctl stop <service> — Stop a running service immediately. For example, systemctl stop httpd stops the Apache web server.
systemctl status <service> — Check the status of a service. This shows if it's active (running), its process ID, and recent log entries.
systemctl restart <service> — Restart a service (stop, then start). Use this after changing a service’s configuration.
systemctl reload <service> — Reload a service’s configuration without fully stopping it. Only works if the service supports reloading (e.g. it reloads settings without disconnecting clients).
systemctl enable <service> — Configure the service to start automatically at boot. After enabling, the service will run every time the system starts (unless masked or disabled).
systemctl disable <service> — Stop a service from starting automatically at boot. This does not stop a running service immediately, but it prevents future automatic starts.

These commands cover the most common service management tasks. You can also combine them in scripts or use systemctl status <service> followed by --no-pager to get a full output.

Advanced operations: mask and unmask

Two more advanced systemctl commands are mask and unmask. Masking a service ensures it cannot be started (even manually or by dependencies). For example, systemctl mask <service> links the service unit to /dev/null, making it effectively disabled. This is useful for critical services you want to prevent from ever running (e.g. systemctl mask sshd if you never want SSH on). To undo this, use systemctl unmask <service>, which restores the service so you can start or enable it again. Use these with care, as masking prevents any start of that service.

3. Practical Examples

In RHEL 9, common services you’ll manage include sshd (the OpenSSH server), firewalld (the firewall daemon), and httpd (Apache). Here’s how systemctl works with these:

sshd (OpenSSH Server): The SSH service is usually called sshd on RHEL.
- Check status: systemctl status sshd will show if the SSH server is running.
- Start SSH: systemctl start sshd. Now you can connect via SSH.
- Enable at boot: systemctl enable sshd ensures SSH starts automatically after a reboot.
- After editing /etc/ssh/sshd_config, apply changes with systemctl restart sshd.
firewalld (Firewall daemon): This is RHEL’s default firewall service.
- Check status: systemctl status firewalld shows if it’s active.
- Start firewall: systemctl start firewalld.
- Enable at boot: systemctl enable firewalld.
- Reload rules: After changing zones or rules, use systemctl reload firewalld to apply them without dropping connections.
httpd (Apache Web Server): If you host a website, httpd is the Apache service.
- Start web server: systemctl start httpd.
- Enable at boot: systemctl enable httpd.
- Check status: systemctl status httpd.
- Restart after config change: systemctl restart httpd.

As you can see, the commands are consistent across services: just replace <service> with the name (e.g. sshd, firewalld, httpd). This makes managing services straightforward.

4. Summary

Controlling services on RHEL 9 is straightforward with systemctl. In this article, we covered how to:

Start, stop, and restart services with systemctl start/stop/restart <service>.
Check status of a service with systemctl status <service>.
Enable or disable services at boot using systemctl enable/disable <service>.
Reload a service’s configuration (if supported) with systemctl reload <service>.
Mask and unmask services (systemctl mask/unmask <service>) for advanced use.

These commands form a complete toolkit for everyday service management on RHEL 9. Practice using them with services like sshd, firewalld, and httpd, and you’ll soon feel fully in control of your system’s daemons. Happy administering!

Monitoring Logged-In Users in Linux (Day 7 of 30)

Sheikh Hassaan Bin Nadeem — Wed, 16 Apr 2025 17:57:17 +0000

Introduction
Why Monitoring Logged-In Users Matters
Essential Commands to Monitor Logged-In Users
- who – Simple Overview of Logged-In Users
- w – What Users Are Doing
- users – Quick List of Usernames
- id – See Current User Info
- last – See Login History
Summary

1. Introduction

One of the key responsibilities of a Linux system admin or power user is to understand who is on the system at any given time and what they’re doing. Whether you’re troubleshooting, securing your server, or just curious, knowing how to monitor logged-in users is a basic yet powerful skill.

In this article, we’ll go through essential Linux commands to help you track, monitor, and understand user sessions on your system all using tools that come pre-installed on RHEL 9 (so no extra setup needed).

Let’s dive in.

2. Why Monitoring Logged In Users Matters

In multi-user systems especially in production environments it's important to know:

Who’s currently logged in
What sessions are active
What actions are being taken
Who logged in recently (and when)

This kind of insight can help you catch unauthorized access, detect idle sessions, troubleshoot performance issues, or just better understand system usage.

3. Essential Commands to Monitor Logged In Users

`who` - Simple Overview of Logged-In Users

What it does:

Displays currently logged-in users, along with terminal, login time, and IP (if remote).

Example:

Why it’s useful:

Great for a quick snapshot of who’s on the system and from where.

`w` - What Users Are Doing

What it does:

Displays detailed information about logged-in users and what they are currently doing including uptime, load average, and active processes.

Example:

Why it’s useful:

Gives a real-time, detailed view, especially useful for spotting long-running or idle processes.

`users` - Quick List of Usernames

What it does:

Prints only the usernames of currently logged-in users in a single line.

Example:

Why it’s useful:

Perfect for quick checks or simple scripts where you only need usernames.

`id` - See Current User Info

What it does:

Shows the current user’s UID, GID, and group memberships.

Example:

Why it’s useful:

Helps you understand user permissions, especially useful when troubleshooting access issues or running permission-based scripts.

`last` - See Login History

What it does:

Displays a history of logins, including login time, duration, and source IP.

Example:

Why it’s useful:

Great for auditing login activity and detecting unusual patterns or times.

4. Summary

Monitoring users is not just about curiosity, it’s about control, security, and clarity. These five simple but powerful commands help you keep an eye on your system without installing anything extra:

who: See who's logged in
w: Find out what they’re doing
users: Quick list of usernames
id: Understand user IDs and groups
last: Review login history

If you're working on RHEL 9 (Red Hat Linux) or any other Linux system, these tools will give you the visibility you need to stay in charge.

Let me know in the comments if you want to know more about any specific command!

The Only 6 Commands You Need to Find Anything in Linux (Day 6 of 30)

Sheikh Hassaan Bin Nadeem — Sat, 12 Apr 2025 17:58:15 +0000

Introduction
The 6 Must-Know Commands
- find Find Anything, Anywhere
- grep – Search Within Files
- locate – The Lightning Fast Finder
- which – Find the Location of Binaries
- whereis – Get Binary, Source & Man Page Paths
- type – Check How a Command Will Run
Summary

1. Introduction

Searching is one of the most common things you'll do on a Linux system. Whether you're trying to locate files, understand where a binary lives, or check how a command is interpreted — Linux has a command for that.

In this article, we’ll go over six essential commands that help you find anything on your system, from files and directories to binaries and documentation. Once you're comfortable with these, you'll rarely feel lost in the Linux filesystem again.

2. The 6 Must-Know Commands

`find` – Find Anything, Anywhere

What it is:

The most powerful file search tool in Linux. It walks through directories and finds files based on name, size, type, permissions, modification date, and more.

Use Case:

Find all .log files inside /var/log:

Why It Matters:

When dealing with large systems or deep directory structures, find gives you total control over what to search for and where.

Pro Tip:

Combine with exec or xargs to perform actions on the results:

`grep` – Search Within Files

What it is:

Searches file contents line by line. Great for looking inside files and filtering output.

Use Case:

Find all lines in access.log that contain “404”:

Why It Matters:

grep is perfect when you know what you're looking for but not where it is inside a file.

Pro Tip:

Use with -r to recursively search directories:

`locate` – The Lightning Fast Finder

What it is:

Searches a pre-built database of filenames. Way faster than find, but may not show the latest files unless the database is updated.

Use Case:

Quickly find all files named nginx.conf:

Why It Matters:

Ideal for quick lookups when you're not sure where a file is, but don’t want to wait for find to crawl the filesystem.

Pro Tip:

Run sudo updatedb if it doesn’t find something you just created.

`which` – Find the Location of Binaries

What it is:

Tells you the full path of a command that will be executed when you type it.

Use Case:

Find where python is installed:

Why It Matters:

When you have multiple versions installed (like Python 2 vs Python 3), this helps avoid confusion.

`whereis` – Get Binary, Source & Man Page Paths

What it is:

Gives more comprehensive information than which including binary, source, and manual page locations.

Use Case:

See where all parts of bash are stored:

Why It Matters:

Useful for developers, sysadmins, or learners who want to explore beyond just the executable.

`type` – Check How a Command Will Run

What it is:

Tells you if something is a built-in shell command, alias, function, or external binary.

Use Case:

Check what ls really is:

Why It Matters:

Critical for debugging shell behaviors and avoiding conflicts between aliases, functions, and binaries.

Pro Tip:

Run type -a <command> to see all definitions in order of priority:

3. Summary

Finding things in Linux doesn’t have to be complicated, you just need the right tools. In this article, we covered:

find for powerful and flexible file search
grep for searching within files
locate for super-fast lookups
which, whereis, and type to understand command locations and behavior

These six commands together create a complete toolkit for navigating and understanding your Linux system like a pro. Once you’ve mastered them, you’ll waste less time searching and more time doing.

The Magic of Aliases in Bash (Day 5 of 30)

Sheikh Hassaan Bin Nadeem — Thu, 10 Apr 2025 21:57:45 +0000

Introduction
What Are Bash Aliases?
Creating Temporary Aliases
Making Aliases Permanent
Real-World Examples (The Good Stuff)
Bonus: Use Bash Functions as Aliases on Steroids
Summary

1. Introduction

Ever feel like you're typing the same Linux command again and again... and again?

That’s exactly where I found myself, typing git status, ls -la, cd ../.., and even rewriting long sudo commands when I forgot to prefix them.

Then I discovered the magic of bash aliases.

These tiny shortcuts are absolute game-changers. Not only do they save time, but they also help avoid common mistakes (like accidentally deleting files with rm *).

Let’s explore what they are, how to use them, and why they’re a must-have in every CLI workflow.

2. What Are Bash Aliases?

Aliases are basically nicknames for commands. You type something short and Bash knows you actually meant something longer.

It’s like having a keyboard macro for your terminal.

Example:

alias ll='ls -la'

Now, whenever you type ll, it will run ls -la. Beautifully simple.

3. Creating Temporary Aliases

Let’s start small. These aliases work during the current terminal session (they vanish after you close it).

alias gs='git status'
alias cls='clear'
alias ..='cd ..'

Try typing those directly into your terminal and give them a spin. You’ll feel 10x faster immediately.

4. Making Aliases Permanent

You don’t want to set these every single time you open a new terminal, right? Let’s make them stick.

Here’s how:

Open your .bashrc (or .zshrc if you use zsh):

vim ~/.bashrc

Scroll down and add your aliases:

alias gs='git status'
alias ga='git add .'
alias gc='git commit -m'
alias rm='rm -i'  # prompts before deleting
alias update='sudo apt update && sudo apt upgrade'

Save and exit Vim (don’t forget :wq) then reload your shell:

source ~/.bashrc

Done. Your shortcuts are now permanent.

5. Real-World Examples (The Good Stuff)

Here’s a few of my favorite aliases I now use daily:

alias gs='git status'
alias ga='git add .'
alias gc='git commit -m'

alias ..='cd ..'
alias ...='cd ../..'

alias cls='clear'
alias pls='sudo !!'  # repeat last command with sudo

And yes, that last one has saved me from so many "permission denied" frustrations.

6. Bonus: Use Bash Functions as Aliases on Steroids

Sometimes a simple alias isn't enough. You want logic. Enter bash functions:

mkcd() {
  mkdir -p "$1"
  cd "$1"
}

Now you can do:

mkcd my-new-folder

And it will create the folder and move you into it. One command. Two jobs. Clean.

7. Summary

Bash aliases are more than a trick, they’re a productivity superpower. They:

Cut your typing time in half
Reduce silly mistakes (like rm accidents)
Make you look and feel like a CLI ninja

Start small, build your own alias list, and before you know it, your terminal will feel like it was built just for you.

Tomorrow, I’ll be exploring something that often goes under the radar, how to use find and grep like a boss. But until then, go make your terminal feel like home.

Happy Linux-ing!

The Most Common Vim Mistakes You’re Probably Making (Day 4 of 30)

Sheikh Hassaan Bin Nadeem — Wed, 09 Apr 2025 20:28:01 +0000

Introduction
Staying in Insert Mode Too Long
Using Arrow Keys Instead of hjkl
Not Learning Navigation Commands
Ignoring Visual Mode (and still using the mouse)
Never Customizing .vimrc
Forgetting How to Quit (yes, still)
Thinking You Know Vim After the First Week
Summary

1. Introduction

When I first started using Vim, I felt like I was trying to fly a spaceship just to edit a line of text. And even after “learning” it, I realized I was doing so many things the wrong way — or at least, the hard way.

This post is a list of the most common Vim mistakes I made (and sometimes still make), along with the better, smarter ways to use Vim. If you’re new to Vim or just winging it through the terminal, chances are you’ll find yourself nodding at a few of these.

Let’s get into it.

2. Staying in Insert Mode Too Long

Most of us treat Insert mode like our default playground. Type i, write code or text like we’re in Notepad, then hit Esc when we’re done.

But in Vim, Insert mode is not the main show. Normal mode is where the power lies. Moving around, editing, replacing, deleting all happen faster and more efficiently in Normal mode.

Mistake: Staying in Insert mode to move the cursor and make changes.

Fix: Drop into Insert mode only when you actually need to type something. Return to Normal mode quickly to navigate and manipulate.

3. Using Arrow Keys Instead of hjkl

Arrow keys work in Vim, but they're slow and break your flow. Your hands leave the home row. It ruins the whole point of Vim's design.

Mistake: Using arrow keys to move around.

Fix: Start using h (left), j (down), k (up), and l (right). It takes time, but once your muscle memory adapts, you won’t want to go back.

If it helps, try disabling arrow keys temporarily in your .vimrc:

" Disable arrow keys
autocmd! VimEnter * noremap <Up> <Nop>
autocmd! VimEnter * noremap <Down> <Nop>
autocmd! VimEnter * noremap <Left> <Nop>
autocmd! VimEnter * noremap <Right> <Nop>

4. Not Learning Navigation Commands

Scrolling line by line? Holding j until you reach the end of the file? We’ve all done it. But Vim gives us power tools:

w → Move forward by a word
b → Move backward by a word
0 → Move to beginning of the line
^ → First non-blank character
$ → End of the line
gg → Top of the file
G → Bottom of the file

Mistake: Navigating like you're in a basic editor.

Fix: Master Vim's navigation keys. They save you tons of time.

5. Ignoring Visual Mode (and still using the mouse)

Selecting text using a mouse in Vim? That's a sign you're missing one of Vim's coolest modes: Visual mode.

Press v to enter Visual mode (character selection)
Press V for line selection
Press Ctrl+v for block/column mode

Once in Visual mode, you can move using hjkl and apply actions like delete (d), yank (y), or change (c).

Mistake: Using the mouse or skipping Visual mode.

Fix: Practice visual selection and commands. You’ll edit faster, and without lifting your hands.

6. Never Customizing `.vimrc`

Out-of-the-box Vim is... bare. If you're not tweaking your .vimrc, you're missing out on major improvements:

set number              " Show line numbers
set relativenumber      " Show relative line numbers
set autoindent          " Keep indentation on new lines
set tabstop=4           " Set tab width
syntax on               " Enable syntax highlighting

Mistake: Using Vim as-is forever.

Fix: Learn how to configure your .vimrc file. Start small, tweak often.

💡 What is .vimrc?

.vimrc is a configuration file that lives in your home directory ~/.vimrc). It's used to personalize Vim based on your preferences — you can set options like line numbers, indentation, syntax highlighting, remap keys, and so much more.
Here's how to create or open it:
vim ~/.vimrc
Example content:
set number
syntax on
set tabstop=4
set shiftwidth=4
set expandtab
Once saved, these settings will load every time you open Vim.

7. Forgetting How to Quit (yes, still)

This one never dies. Even after months of Vim, sometimes I still catch myself typing :wq! when I just needed :q.

Mistake: Panicking when trying to exit Vim.

Fix: Get comfortable with the essentials:

:w → Save
:q → Quit
:wq → Save and quit
:q! → Quit without saving

And yes, ZZ still works too.

8. Thinking You Know Vim After the First Week

Vim is deep. Like rabbit-hole deep.

Just because you’ve memorized :wq, i, and a few navigation keys doesn’t mean you’re done. Vim has macros, registers, plugins, buffers, folds, and so much more.

Mistake: Settling too early.

Fix: Keep exploring. Read the Vim help (:help). Watch other people use it. Keep refining your flow.

Your goal? Make editing feel like typing. Seamless. Thoughtless. Fast.

9. Summary

Vim isn’t hard — it’s just different. And it’s easy to make mistakes when you treat it like a regular editor.

These were the things I did wrong. You might be doing some of them too. And that’s okay. You’re learning. And that's how we all progress.

If you’ve got a Vim mistake you used to make (or still do), share it in the comments. Let’s grow together; one keystroke at a time.

Understanding Users in Linux: Who’s Using the System? (Day 3 of 30)

Sheikh Hassaan Bin Nadeem — Tue, 08 Apr 2025 20:43:27 +0000

What is a User?
Types of Users in Linux
How Linux Identifies Users (UIDs)
Where Is User Information Stored?
Essential User Management Commands
Summary

1. What is a User?

A user is simply someone who logs into a Linux system. Each user has an account; a unique identity, that determines:

What they can do
What files they own
What resources they can access

You could think of it like this: if Linux was a house, users are the people with keys, each with different access levels.

2. Types of Users in Linux

a. System Users

These accounts are created automatically when Linux is installed. They're mostly used by the system and background services, not real people.

Examples:

root – the superuser (has unlimited control)
apache – used by web servers
mysql – used by the database engine

b. Normal Users

These are the actual human users who log in to do work. They can be added, edited, or deleted by an administrator (or the root user).

Example:
If you create a user called Hassaan, Linux sets up an account for Hassaan, gives them a home directory, and assigns them basic privileges.

3. How Linux Identifies Users (UIDs)

Behind the scenes, Linux assigns a UID (User ID) to every account. This UID is what the system actually uses to track users, not the usernames.

UID Ranges:

0 – 999 → System Users
1000 – 60000 → Normal Users

4. Where Is User Information Stored?

Linux keeps user data in special configuration files:

- `/etc/passwd`

Stores general info like usernames, UIDs, home directories, and default shells.

- `/etc/shadow`

Stores password-related info (in a secure, encrypted format). Only root can read this file.

5. Essential User Management Commands

➕ Create a New User

useradd <username>

🔑 Set or Change Password

passwd <username>

🧾 Check User Account Info

grep <username> /etc/passwd

🔐 Check Password Info

grep <username> /etc/shadow

🔁 Switch to Another User

su <username>

❌ Delete a User Account

Keep user data:

userdel <username>

Delete user and their home directory:

userdel -r <username>

6. Summary

Today’s Linux journey focused on user management, from creating users to checking their information and managing their accounts. Here’s a quick recap:

System users vs normal users
Linux uses UIDs to identify users (not just usernames)
You can easily create, modify, and delete users via the terminal
User data is stored in /etc/passwd and /etc/shadow

Tomorrow, we’ll take it a step further and dive into groups and permissions, how users interact with files and what access they have.

Until then, try running a few of these commands on your own system to explore how users are managed. You might discover some interesting things!

Mastering File Operations in Linux: The Power of cp, mv, mkdir, and More (Day 2 of 30)

Sheikh Hassaan Bin Nadeem — Mon, 07 Apr 2025 23:19:31 +0000

Introduction
The Power of Simple Commands
- cp – Copy Files and Folders
- mv – Move or Rename with Control
- mkdir – Create Directories Like a Pro
- rm – Remove with Caution
- touch – Quickly Create Empty Files
Summary

1. Introduction

When working with Linux, the real magic often begins with basic file operations. Whether you’re organizing configuration files, preparing codebases, or setting up automated scripts — commands like cp, mv, mkdir, and others are your everyday tools. Think of them as your file management toolkit — fast, reliable, and always available right inside your terminal.

2. The Power of Simple Commands

`cp` – Copy Files and Folders

What it is:

The cp command lets you copy files or directories from one place to another.

Use Case:

Copy a file from your current directory to a backup folder:

Why It Matters:

Backups often start here. You may not use cp for large-scale backup solutions (like rsync or tar), but for small manual backups or quick duplication, it's perfect.

Pro Tip:

Use -r for recursive copy (directories), and -v for verbose output.

`mv` – Move or Rename with Control

What it is:

Moves files/directories from one location to another. It also acts as the "rename" command in Linux.

Use Case:

Rename a file:

Move a file to another folder:

Why It Matters:

When organizing files or managing logs, mv helps clean things up or archive old files.

Pro Tip:

If you're renaming a lot of files, combine mv with shell scripting or find for batch renaming.

`mkdir` – Create Directories Like a Pro

What it is:

Used to create one or more directories.

Use Case:

Create a folder structure in one go:

Why It Matters:

Directory planning is key for maintainability. mkdir helps you quickly set up organized environments.

Pro Tip:

Use -p to create parent directories automatically — it saves time and prevents errors.

`rm` – Remove with Caution

What it is:

Deletes files or directories.

Use Case:

Remove a file:

Remove a directory and everything inside it:

Why It Matters:

Clean up is part of system maintenance. But misuse can be risky — especially when used with -rf.

Pro Tip:

On modern Linux systems like Red Hat 9, rm -rf / is blocked by default for safety — but you should never try it anyway.

If you force it using --no-preserve-root, it will attempt to delete your entire system.

Instead, set an alias to add a confirmation prompt:

`touch` – Quickly Create Empty Files

What it is:

Creates new, empty files or updates timestamps on existing ones.

Use Case:

Create a new log file or placeholder:

Why It Matters:

Used in scripting, testing, and placeholder creation. It’s lightweight but powerful.

Pro Tip:

Combine with mkdir to create folder/file structures for new projects:

3. Summary

The basic commands in Linux like cp, mv, mkdir, rm, and touch are more than just simple tools — they’re fundamental to daily workflows. Once you get comfortable with them, you’ll navigate your system with ease, automate smartly, and build the habits of a Linux power user.

As we progress in this 30-day journey, mastering these basics will give you the confidence to handle more advanced scripting, backups, and DevOps tasks with clarity.

Linux Filesystem: Understanding the Core Structure (Day 1 of 30)

Sheikh Hassaan Bin Nadeem — Sun, 06 Apr 2025 21:46:40 +0000

Introduction
Understanding the Root / Directory
/home – User Data Lives Here
/root – Superuser’s Space
/bin and /sbin – Essential Binaries
/etc – Configurations
/usr – Shared User Resources
/opt – Optional Software
/tmp – Temporary Storage
/proc – Process Info
/var – Logs and Runtime Data
/dev – Device Interfaces
Summary

1. Introduction

The Linux filesystem forms the backbone of how data, applications, and services are organized on any Linux-based system. Whether you're working as a system admin, cloud engineer, or DevOps practitioner, knowing where everything lives is a critical first step in becoming comfortable with Linux.

2. Linux Filesystem Breakdown

`/` – Root Directory

What it is:

The root (/) is the top-level directory in the Linux hierarchy. Everything begins here & every other directory branches from this point.

Use Case:

All filesystems are mounted under this directory. It’s your starting point when navigating the system via the command line.

Why It Matters:

Understanding that everything flows from / helps you avoid confusion when navigating or scripting in Linux.

Pro Tip:

Avoid writing files directly in /. It's reserved for system-level folders, not user data.

`/home` – User Home

What it is:

Contains personal directories for each user (e.g., /home/ali). This is where user files, settings, and custom configurations are stored.

Use Case:

A developer or system user keeps all project files, downloads, and personal shell settings here.

Why It Matters:

Keeps user data isolated from system files, reducing the risk of accidental system changes.

Pro Tip:

Set up disk quotas or backups per /home/username to manage user storage effectively.

`/root` – Superuser’s Space

What it is:

This is the root user’s personal directory, separate from other users for security reasons.

Use Case:

System administrators use this when logged in as root to perform high-privilege tasks.

Why It Matters:

Segregates critical administrative tasks from regular user operations.

Pro Tip:

Avoid using the root account directly unless absolutely necessary. Use sudo instead.

`/bin` and `/sbin` – Essential Binaries

What it is:

/bin: Basic commands available to all users (e.g., cp, mv, ls).
/sbin: System-level commands for admins (e.g., shutdown, mount, ip).

Use Case:

Commands stored here are used during both normal operations and system recovery.

Why It Matters:

These are available even if other directories like /usr are not mounted during boot.

Pro Tip:

Use which or whereis to locate command binaries and verify where they’re stored.

`/etc` – Configurations

What it is:

Holds all system-wide configuration files for services, applications, and system settings.

Use Case:

Edit files like /etc/ssh/sshd_config to configure the SSH server.

Why It Matters:

This is where the brain of your system lives in terms of how it behaves.

Pro Tip:

Always back up config files before modifying them. Use version control if possible.

`/usr` – Shared User Resources

What it is:

Contains user-facing programs and libraries. Think of it as a second root for user applications.

Use Case:

Software installed from repositories often lives here (/usr/bin, /usr/lib).

Why It Matters:

Separates core OS files from user-installed applications and documentation.

Pro Tip:

Don’t confuse /usr with /home: this is for shared resources, not individual user data.

`/opt` – Optional Software

What it is:

Used for manually or third-party installed software that doesn’t come from package managers.

Use Case:

Installing a custom monitoring tool or analytics dashboard.

Why It Matters:

Keeps your manual installs from cluttering system directories.

Pro Tip:

Use this for organizing non-standard apps like Java, ElasticSearch, etc.

`/tmp` – Temporary Storage

What it is:

A scratch space for temporary files. Often cleared on reboot.

Use Case:

Used by applications or users to store temporary runtime data.

Why It Matters:

Helps avoid clutter in main directories and improves app performance.

Pro Tip:

Never store critical data here. It could be wiped after a restart.

`/proc` – Process Info

What it is:

A virtual filesystem containing runtime system information and process data.

Use Case:

Check system resources (/proc/cpuinfo, /proc/meminfo) or inspect running processes.

Why It Matters:

Provides a real-time window into system operations.

Pro Tip:

You can read from it like a file using cat, e.g., cat /proc/uptime.

`/var` – Logs and Runtime Data

What it is:

Contains files that frequently change: logs, caches, mail, etc.

Use Case:

Monitor logs (/var/log/syslog, /var/log/auth.log) to debug errors.

Why It Matters:

Critical for system monitoring, troubleshooting, and auditing.

Pro Tip:

Set up log rotation and monitoring alerts on this directory.

`/dev` – Device Interfaces

What it is:

Represents hardware devices as files (e.g., /dev/sda for a hard disk).

Use Case:

Mount USB drives or interact with hardware components directly.

Why It Matters:

Allows Linux to treat everything as a file—including hardware.

Pro Tip:

Use lsblk or fdisk -l to safely explore connected devices.

3. Summary

The Linux filesystem is logically structured, and each directory has a specific role.
Mastering it gives you control, confidence, and clarity while working on servers or embedded systems.
This foundational knowledge will help in upcoming topics like user management, permissions, and system troubleshooting.

DEV Community: Sheikh Hassaan Bin Nadeem

How to Take Remote Backups Using rsync Over SSH (Day 12 of 30)

Table of Contents

1. Introduction

2. Why Organizations Still Use rsync

3. Understanding rsync and SSH

4. Step-by-Step Guide to Remote Backups

5. Real-World Use Case

6. Summary

Access Control Lists in Linux for Granular Permissions (Day 11 of 30)

Table of Contents

1. Introduction

2. Why Traditional Permissions Fall Short

3. What Are ACLs and When to Use Them

4. Basic ACL Commands: getfacl and setfacl

Check current ACLs

Give read permission to a user

Give write access to a group

Set default ACLs on a directory (for new files)

5. Real-World Examples

Example 1: Give read access to alice on a log file

Example 2: Block write access for group interns

Example 3: Make sure all new files in a folder are readable by user sam

6. Removing and Managing ACLs

Remove specific ACL entry

Remove all ACLs and go back to normal permissions

7. Best Practices

8. Summary

Understanding /etc/passwd – Linux User Account Properties (Day 10 of 30)

Table of Contents

1. Introduction

2. Why Understanding User Account Properties Matters

3. The /etc/passwd File – A Goldmine of User Info

4. Breaking Down Key Fields

5. How to View and Interpret User Info

View All Usernames

View UID and GID for a User

See Default Shell for a User

6. Summary

Understanding Linux File Permissions - The Smarter Way (Day 9 of 30)

Table of Contents

1. Introduction

2. Understanding File Permissions in Linux

3. The Symbolic Method (The Harder Way)

4. The Numeric Method (The Smarter Way)

5. Real-World Examples to Practice

6. Summary

Control Firewall, OpenSSH & Other System Services with systemctl (Day 8 of 30)

Table of Contents

1. Introduction

2. Understanding systemctl

Advanced operations: mask and unmask

3. Practical Examples

4. Summary

Monitoring Logged-In Users in Linux (Day 7 of 30)

Table of Contents

1. Introduction

2. Why Monitoring Logged In Users Matters

3. Essential Commands to Monitor Logged In Users

who - Simple Overview of Logged-In Users

w - What Users Are Doing

users - Quick List of Usernames

id - See Current User Info

last - See Login History

4. Summary

The Only 6 Commands You Need to Find Anything in Linux (Day 6 of 30)

Table of Contents

1. Introduction

2. The 6 Must-Know Commands

find – Find Anything, Anywhere

grep – Search Within Files

locate – The Lightning Fast Finder

which – Find the Location of Binaries

whereis – Get Binary, Source & Man Page Paths

type – Check How a Command Will Run

3. Summary

The Magic of Aliases in Bash (Day 5 of 30)

Table of Contents

1. Introduction

2. What Are Bash Aliases?

4. Basic ACL Commands: `getfacl` and `setfacl`

Example 1: Give read access to `alice` on a log file

Example 2: Block write access for group `interns`

Example 3: Make sure all new files in a folder are readable by user `sam`

3. The `/etc/passwd` File – A Goldmine of User Info

`who` - Simple Overview of Logged-In Users

`w` - What Users Are Doing

`users` - Quick List of Usernames

`id` - See Current User Info

`last` - See Login History

`find` – Find Anything, Anywhere

`grep` – Search Within Files

`locate` – The Lightning Fast Finder

`which` – Find the Location of Binaries

`whereis` – Get Binary, Source & Man Page Paths

`type` – Check How a Command Will Run

6. Never Customizing `.vimrc`

- `/etc/passwd`

- `/etc/shadow`

`cp` – Copy Files and Folders

`mv` – Move or Rename with Control

`mkdir` – Create Directories Like a Pro

`rm` – Remove with Caution

`touch` – Quickly Create Empty Files

`/` – Root Directory

`/home` – User Home

`/root` – Superuser’s Space

`/bin` and `/sbin` – Essential Binaries

`/etc` – Configurations

`/usr` – Shared User Resources

`/opt` – Optional Software

`/tmp` – Temporary Storage

`/proc` – Process Info

`/var` – Logs and Runtime Data

`/dev` – Device Interfaces