DEV Community: Alexand

The DevOps Mindset Operating System

Alexand — Sun, 11 Jan 2026 16:04:43 +0000

📌 Table of Contents

Why Mindset Comes Before Tools
- Long-Term Compounding
- Identity Transformation
- High Professional Standards
- Systematic Productivity
The Engineering Mindset: Think Like a Builder
Why Motivation Fails (and Systems Don’t)
- You Stop Letting Emotions Control Your Day
- You Benefit from Compounding
- You Reduce Friction with Smart Routines
- You Avoid “Performance Leaks”
- You Stay Accountable Through Measurement
Your Personal Operating System
Final Thought

Most people think DevOps starts with tools — Docker, Kubernetes, CI/CD pipelines, cloud platforms, and all the shiny tech.

But here’s the truth that hits harder the deeper you go into this field:

DevOps is not a toolset. It’s an operating system for your mind.

And if your mindset is outdated, no amount of tools will save your career.

This is exactly what Pravin Mishra teaches in the first week of his DevOps Micro‑Internship — a week that has nothing to do with YAML files or Linux commands, and everything to do with building the human behind the engineer.

Let’s break it down in simple English.

Why Mindset Comes Before Tools

Pravin’s program starts with four core pillars — think of them as the BIOS of your DevOps career:

1. Long‑Term Compounding

Small actions done daily beat big bursts of effort.

DevOps is a marathon, not a sprint.

2. Identity Transformation

You can’t build a DevOps career with a “version 1.0” identity.

You need to upgrade yourself — habits, routines, discipline, and how you see your own potential.

3. High Professional Standards

Reliability > Intelligence.

Consistency > Motivation.

In the real world, the person who shows up every day wins.

4. Systematic Productivity

Success is not magic.

It’s a system — repeatable, measurable, and boring in the best possible way.

The Engineering Mindset: Think Like a Builder

Pravin pushes participants to adopt an engineering mindset:

Question assumptions
Seek objective truth
Treat failures as data, not drama
Build systems that work even when you don’t feel like working

This mindset is what separates professionals from hobbyists.

Why Motivation Fails (and Systems Don’t)

Motivation is like weather — sunny today, stormy tomorrow.

It’s unreliable and perishable.

A system, on the other hand, is like train tracks.

Even if the steam is low, the train still moves in the right direction.

Here’s how a systems‑based mindset keeps you consistent:

1. You Stop Letting Emotions Control Your Day

When you have a routine, you don’t “negotiate with your emotions.”

You follow the plan — the math of the system.

Example:

Instead of “I’ll study when I feel motivated,”

you commit to two 45‑minute blocks every day, no excuses.

2. You Benefit from Compounding

One hour a day for 100 days beats 10 hours in one weekend.

Small, repeated actions → big long‑term results.

This is how skills grow.

This is how reputations grow.

This is how careers grow.

3. You Reduce Friction with Smart Routines

Systems like:

Timed focus sprints
Removing phone distractions
Starting the day with movement + deep work
Designing your environment for focus

These reduce mental friction and prevent burnout.

A structured morning beats a chaotic one every time.

4. You Avoid “Performance Leaks”

Multitasking is a lie.

Context switching kills productivity.

Pravin teaches “mode separation”:

Learning days
Creating days
Admin days

This keeps your brain in one gear at a time, so you produce real work without feeling overwhelmed.

5. You Stay Accountable Through Measurement

What gets measured gets repeated.

Systems include:

Scoreboards
Habit trackers
Weekly reviews
Submission logs
Deep work counters

This creates clarity — not the vague “I think I’m improving,” but real data.

Your Personal Operating System

Pravin’s message is simple:

Success is not a feeling.

Success is a system.

A system that runs every week, whether you feel motivated or not.

A system that turns you into a reliable professional — and reliability is a superpower in tech.

Final Thought

If motivation is the steam, your system is the track.

Steam rises and falls.

But the track keeps you moving forward, no matter the weather.

That’s the DevOps Mindset Operating System.

And once you install it, your career stops depending on luck, mood, or motivation — and starts running on discipline, clarity, and compounding progress.

Behind the Scenes of Your Files: Why Inodes Are the Real Story in Linux

Alexand — Sat, 02 Aug 2025 07:33:06 +0000

When you open a file in Linux, you're seeing just the tip of the iceberg. Beneath the surface is a structure called an inode—and understanding how it works is the key to making sense of hard links, soft links, and what really happens when you rename or delete a file.

What’s an Inode?

An inode is a hidden record in the Linux file system that stores everything about a file except its name. It holds details like:

Where the file’s content lives on the disk
The file’s size and timestamps
Ownership and permissions

Each file has a unique inode number. Think of it as the file’s true identity. The name you see in a folder is just a label that points to it.

Hard Links: Multiple Labels, One File

Creating a hard link is like putting a second label on the same package. Both names point to the same inode. That means they’re actually the same file.

If you change the contents of one, the other reflects those changes instantly. If you delete one, the other stays alive—because the inode still exists and another name still leads to it.

ln original.txt copy.txt

In this example, original.txt and copy.txt are hard links. They’re just two names for the same file.

Soft Links: A Shortcut with Limits

Soft links (also called symbolic links) work differently. Instead of pointing directly to the inode, they point to the file name.

This means they’re more like shortcuts. If the target file is moved or deleted, the soft link breaks because it’s looking for a name that no longer exists.

ln -s original.txt shortcut.txt

Now, shortcut.txt leads to original.txt. But if original.txt disappears, the shortcut becomes useless.

Why Inodes Matter

Understanding inodes reveals why links behave the way they do. Hard links rely on inode numbers—so they’re deeply connected. Soft links rely on file names—so they’re more fragile.

Inodes also explain why deleting a file doesn’t always erase its contents. If another hard link still points to the same inode, the data stays.

How to See Inodes in Action

You can view inode numbers with a simple command:

ls -i

Or check detailed info using:

stat filename.txt

This shows the inode number and how many links point to it. Try creating hard and soft links, then inspect them using these tools. You’ll see Linux's hidden architecture come to life.

Inodes are quiet, but powerful. They don’t ask for attention—but once you understand them, you’ll never look at file names the same way again.

How to Enable Virtualization in BIOS/UEFI — A Step-by-Step Guide for Cloud Learners

Alexand — Sun, 13 Jul 2025 08:19:04 +0000

If you’re learning about cloud computing, virtualization is a word you’ll hear a lot. It’s what lets one computer act like many, giving you virtual machines to run different operating systems or cloud environments. But before tools like VirtualBox or Docker can work properly on your system, virtualization needs to be turned on—and it starts in your BIOS or UEFI.

Don't worry if that sounds technical. This guide keeps things simple and walks you through every step so you can get virtualization working on your laptop or PC.

What Is Virtualization and Why You Need It

Virtualization lets one physical machine run many virtual systems. It's used for:

Creating virtual machines
Running emulators like Android Studio
Working with cloud platforms
Practicing container tools like Docker or Podman

If virtualization isn’t enabled, these tools won’t run right—or might not run at all.

How to Check If Virtualization Is Enabled

Before jumping into BIOS or UEFI, let’s check:

Windows users:

Press Ctrl + Shift + Esc to open Task Manager
Click the Performance tab
Select CPU → Look for “Virtualization: Enabled” or “Disabled”

Linux users (like Red Hat):

Run this in the terminal:

egrep -wo 'vmx|svm' /proc/cpuinfo

vmx = Intel processor supports virtualization
svm = AMD processor supports virtualization If nothing shows up, your system might not support it.

Steps to Enable Virtualization in BIOS/UEFI

Important: Be careful in BIOS/UEFI. Use arrow keys and avoid changing other settings.

Step 1: Restart Your Computer

You need to access BIOS/UEFI during startup. So first, restart.

Step 2: Enter BIOS/UEFI

When the screen first lights up, press the right key—usually one of:

Brand	Key to press at startup
Dell	`F2` or `Delete`
HP	`Esc` or `F10`
Lenovo	`F1` or `F2`
Acer	`F2`
ASUS	`Delete` or `F2`

You’ll see a setup screen. That’s your BIOS or UEFI.

Step 3: Find Virtualization Settings

Use arrow keys or mouse (in UEFI) to explore menus like:

Advanced
CPU Configuration
System Configuration
Security (sometimes)

Look for one of these:

Intel Virtualization Technology (VT-x)
AMD-V
SVM Mode

Step 4: Enable It

When you find the setting:

Select it
Change it to Enabled
Save and exit (usually F10 or look for Save & Exit option)

Your system will restart.

Step 5: Confirm It’s Working

After reboot, check again:

Windows: Open Task Manager → Performance → CPU
Linux: Run egrep -wo 'vmx|svm' /proc/cpuinfo

Now virtualization should be enabled and ready.

What’s Next?

Once virtualization is turned on, you can:

Run VirtualBox or VMware for practice labs
Use Podman or Docker for containers
Learn how cloud servers manage virtual resources

Turning on virtualization is the first step in cloud learning—and now you’ve done it.

Work Smarter with Tmux in Red Hat Linux — Keep Your Terminal Tasks Safe and Organized

Alexand — Sat, 12 Jul 2025 11:27:32 +0000

📚 Table of Contents

What Tmux Can Do
Why Tmux Is Handy
Example You Can Try
Useful Tmux Commands
How to Install Tmux
Wrap-Up

Have you ever been in the middle of downloading files or updating your system when your terminal suddenly closed or your internet dropped? It’s frustrating, especially when you have to start over. Tmux is a simple tool in Red Hat Linux that solves this problem.

With tmux, you can keep your work running in the background, even if you close your terminal or lose connection. You can also split your screen and run more than one task at a time—all in one place.

What Tmux Can Do

Keeps your session running if you disconnect or shut your terminal
Lets you split your screen and multitask inside one terminal window
Helps you switch between different tasks easily
Allows you to pause and return to your work anytime

Why Tmux Is Handy

You won’t lose progress if your connection drops
You can do more without opening extra windows
It helps you keep your terminal workspace neat and organized
It's great for working with remote servers, updates, or downloads

Example You Can Try

Let’s say you’re installing software that takes time:

Start a tmux session:

   tmux

Run your install command:

   sudo dnf install big-software

Press Ctrl + B, then D to safely leave the session.
Close your laptop or walk away.
Come back later and type:

   tmux attach

Your session is still running, just like you left it.

Useful Tmux Commands

Task	What to Type
Start a session	`tmux`
Detach session	`Ctrl + B`, then `D`
Reattach session	`tmux attach`
Split window (horizontal)	`Ctrl + B`, then `"`
Split window (vertical)	`Ctrl + B`, then `%`
Switch between panes	`Ctrl + B`, then arrow key
View sessions	`tmux ls`
Close a session	`tmux kill-session -t name`

How to Install Tmux

If tmux isn’t installed yet:

sudo yum install tmux

It’s quick to install and light on resources.

Wrap-Up

Tmux is a small tool that makes a big difference. It keeps your work running safely and lets you do more in the same space. If you use Red Hat Linux, tmux can make your terminal sessions easier, cleaner, and more reliable.

AutoFS in Red Hat Linux — Let Your System Mount Drives Without You Askin

Alexand — Thu, 10 Jul 2025 19:34:56 +0000

You know when you try to open a folder or access a USB drive, and it’s not ready or gives an error? That’s frustrating. AutoFS solves this problem. It’s a simple tool in Red Hat Linux that gets folders and drives ready right when you need them, and closes them when you’re done.

Here’s how AutoFS works, why it helps, and how you can use it easily.

What AutoFS Does

AutoFS lets your system:

Open folders or drives only when you use them
Close them when you stop using them

No need to type special commands or remember long instructions. AutoFS watches quietly and acts when needed.

Why It Helps

You save time — no manual mounting
No errors from broken or missing folders
Keeps your system clean — nothing stays open longer than needed
Great for office folders, USBs, or remote drives

Simple Example

You work with a folder on your company network. Without AutoFS, you have to type:

mount -t nfs server:/share /mnt/share

With AutoFS:

You just go to /mnt/share
AutoFS sees that you’re trying to use it and opens it for you
When you stop using it, AutoFS closes it again

How to Set It Up

Step 1: Install AutoFS

sudo yum install autofs

Step 2: Start the Service

sudo systemctl start autofs
sudo systemctl enable autofs

Step 3: Set Up the Main File

Edit /etc/auto.master:

sudo nano /etc/auto.master

Add:

/mnt  /etc/auto.misc

This tells AutoFS to use another file to decide what folders to open under /mnt.

Step 4: Add a Rule

Edit /etc/auto.misc:

sudo nano /etc/auto.misc

Example rule:

docs  -fstype=nfs  server:/shared/documents

This means when you go to /mnt/docs, AutoFS opens the network folder for you.

Step 5: Apply Changes

sudo systemctl restart autofs

Test It

Go to the folder:

cd /mnt/docs

If everything is right, the folder will open. No extra commands. Just works.

AutoFS saves you from typing, keeps your system clean, and gets things ready when you need them. If you use drives or shared folders often, it’s a simple way to make Red Hat Linux easier to use.

Keyboard Kung Fu — Mastering CTRL Commands in the Red Hat Linux Terminal

Alexand — Tue, 08 Jul 2025 14:44:50 +0000

🧹 CTRL + U — Clear the Line
❌ CTRL + C — Cancel the Current Command
💤 CTRL + Z — Pause a Process (Send to Background)
🧤 CTRL + D — End of Input / Exit Terminal
🧠 Real-Life Mini Scenario
🧩 Final Thought

So, you’ve braved the terminal. You’ve typed, you’ve squinted at error messages, maybe even panicked once or twice. But here’s the secret no one tells beginners: the real power lies not just in commands like ls and cd:it’s in mastering those sneaky little keyboard shortcuts that can save your time, sanity, and fingers.

Red Hat Linux (and most other Unix-based systems) gives you a bunch of quick-fire combinations using the CTRL key that work like magic behind the scenes. Let’s break down four super handy ones every terminal user should know—whether you’re just poking around or building empires in code.

🧹 `CTRL + U` — Clear the Line

What it does: Deletes everything you typed on the current command line.
Why it’s useful: Avoids endless backspacing when you change your mind.
Use case: You start typing a long command and realize halfway it's the wrong one. Hit CTRL + U—poof! Clean slate.

$ sudo apt-get install something-super-long
# Oops! Just hit CTRL + U to erase it all instantly.

❌ `CTRL + C` — Cancel the Current Command

What it does: Terminates whatever process or command is running in the terminal.
Why it’s useful: Gets you out of hanging commands or unwanted operations.
Use case: You ran a command and it’s taking forever—or maybe you didn't mean to run it at all.

$ ping google.com
# It keeps pinging until you stop it—use CTRL + C to end it.

Bonus: Also works when you're inside programs like nano or stuck in a broken script.

💤 `CTRL + Z` — Pause a Process (Send to Background)

What it does: Suspends a running process and pushes it to the background.
Why it’s useful: Useful when you need the terminal for something else right now but don’t want to kill your current task.
Use case: Editing a big file in nano, then suddenly need to check another folder—pause nano, do your thing, and come back.

$ nano long_script.sh
# Need to look something up? Hit CTRL + Z
$ fg   # Brings nano back to the foreground

🧤 `CTRL + D` — End of Input / Exit Terminal

What it does: Sends an "end of file" (EOF) signal. If typed at a prompt, it closes the shell.
Why it’s useful: Lets you gracefully exit programs or even the terminal itself.
Use case: You’re done with your terminal session—no need to type exit.

$ CTRL + D
# Boom. You’re logged out from the terminal session.

Also handy when feeding input into commands manually (like when using cat or a script waiting for you to finish typing).

🧠 Real-Life Mini Scenario

Imagine this: You're editing a config file but need to double-check your disk space first.

You’re inside nano. Hit CTRL + Z to pause.
Run df -h to check your disk.
Type fg to go back into nano.
Realize you're editing the wrong file? Hit CTRL + C to exit immediately.
Want to leave the terminal altogether after fixing everything? CTRL + D closes the show.

Just like that, you’re operating like a Linux ninja.

🧩 Final Thought

These aren't just keystrokes; they're tools to flow through your terminal with ease. Mastering them means fewer mistakes, faster work, and a whole lot more confidence. Whether you're managing servers or just poking around for fun, these shortcuts are your silent superpowers.

Is Your System Talking Back? A Guide to Red Hat Linux Monitoring Tools

Alexand — Mon, 07 Jul 2025 15:38:15 +0000

Why Monitoring Matters
Essential Monitoring Commands (And How to Actually Use Them)
- 1. top
- 2. htop (if installed)
- 3. vmstat
- 4. iostat
- 5. netstat
- 6. df -h
- 7. du -sh
Real-World Monitoring Scenario
Final Word

Let’s be real: your Linux system is quietly doing hundreds of things at once—but how do you know what’s going on under the hood? Whether you’re running a personal server, managing a small business setup, or just geeking out with your own Red Hat Linux installation, monitoring is the key to not flying blind.

Good news: you don’t need to be a command-line ninja to get started. Here’s a simple, no-fluff guide to system monitoring commands in Red Hat Linux and how they help you stay in control of your machine.

Why Monitoring Matters

Imagine driving a car without a dashboard—no speedometer, no fuel gauge, no engine alerts. Pretty risky, right? Well, not monitoring your Linux system is kind of the same. These commands act like your dashboard, showing:

What resources are being used
Whether any processes are hogging memory
If your system is about to crash
Who's doing what on your server

Essential Monitoring Commands (And How to Actually Use Them)

1. `top`

What it does: Gives a live overview of running processes, CPU usage, and memory stats.
Why it's useful: Spot if your system is overloaded or if a rogue process is eating resources.
Use case: Server feels slow? Run top to see if something’s chewing up the CPU.

top

2. `htop` (if installed)

What it does: A prettier and more interactive version of top.
Why it's useful: Easier to read; lets you scroll, search, and kill processes with arrow keys.
Use case: You want to end a frozen process without memorizing its PID.

htop

To install: sudo yum install htop

3. `vmstat`

What it does: Reports on memory, system processes, swap, I/O, and CPU activity.
Why it's useful: Great for catching performance bottlenecks.
Use case: Check if your system is swapping too much (a sign of low memory).

vmstat 5

4. `iostat`

What it does: Shows CPU usage and input/output stats for disks.
Why it's useful: Find out if slow performance is due to disk overload.
Use case: Database is crawling? Use iostat to see if your disk is the bottleneck.

iostat -xz 1 3

5. `netstat`

What it does: Displays network connections, listening ports, and routing tables.
Why it's useful: See who’s connected to your system and where data is flowing.
Use case: Suspect someone's accessing your server? netstat can show active connections.

netstat -tuln

6. `df -h`

What it does: Shows disk space usage in human-readable format.
Why it's useful: Quickly check if you're running out of space.
Use case: Need to install something but it fails mysteriously? df -h might reveal a full disk.

df -h

7. `du -sh`

What it does: Tells you how much space a directory is taking up.
Why it's useful: Perfect for hunting down huge folders.
Use case: Clean-up time! Find which folder is the space hog.

du -sh /path/to/folder

Real-World Monitoring Scenario

Problem: Your web server is slow and pages take forever to load.

Solution:

Start with top or htop to see CPU and memory usage.
Run iostat to check for disk bottlenecks.
Use netstat to check incoming connections and whether too many users are overwhelming the server.
df -h tells you if you're low on storage, which can also cause slowness.

With these few steps, you can pinpoint the issue and take action—whether it’s killing a rogue process or freeing up some disk space.

Final Word

System monitoring sounds technical (and let’s be honest, kind of intimidating), but with Red Hat Linux it’s just a matter of using the right command at the right time. You don’t need to be a guru—you just need curiosity and the courage to type a few words into your terminal.

Understanding Process Signals in Linux

Alexand — Mon, 16 Jun 2025 17:49:12 +0000

What Is a Process Signal?
Real-Life Use Case
Common Process Signals You Should Know
How to Send a Signal Using kill
Using killall for Convenience
Signals Aren’t Just for Crashing Things
Conclusion

If you've ever wondered how you can stop a program in Linux, pause it, or even tell it to restart itself; you're talking about process signals. Think of signals like short messages sent from one part of the system to a program, telling it to do something specific.

This concept might sound technical, but once you get the hang of it, it's incredibly helpful; especially when a program is stuck or misbehaving.

What Is a Process Signal?

In Linux, a signal is a way to communicate with a process (a running program). It’s like sending a note that says, “Hey, do this!” or sometimes, “Hey, stop right now!”

Every process in Linux has a unique ID called a PID (Process ID), and you can send signals to that PID using built-in commands.

Common reasons you'd use signals include:

Stopping unresponsive programs
Gracefully asking a program to shut down
Restarting background services
Pausing or resuming tasks

Real-Life Use Case

Let’s say you're running a script that went into an endless loop and is eating up your computer’s resources. You could press Ctrl + C to stop itbut what if it’s running in the background or on a remote server? That’s where signals come to the rescue.

By using a command like kill, you can send a signal to the process and tell it, “Time’s up—shut down.” And don’t worry, despite the name, kill isn’t always violent. Sometimes it's just a polite request.

Common Process Signals You Should Know

Here are the most common signals and what they do:

Signal	Name	Description
1	SIGHUP	Tells a program to restart (often used for daemons)
2	SIGINT	Interrupts the process (like pressing `Ctrl + C`)
9	SIGKILL	Forcefully kills the process—can’t be ignored
15	SIGTERM	Politely asks the process to terminate (default)
18	SIGCONT	Resumes a paused process
19	SIGSTOP	Pauses the process without killing it

How to Send a Signal Using `kill`

Let’s look at a basic example.

Find the PID of the process Use the ps or pidof command:

   ps aux | grep myprogram  
   pidof myprogram

Send a signal using kill:

   kill -SIGTERM 1234

Or even more simply:

   kill 1234

This sends a SIGTERM (signal 15), which is the default.

Force kill (if the program ignores SIGTERM):

   kill -9 1234

Using `killall` for Convenience

Instead of using the PID, you can also send signals by name with killall:

killall -SIGKILL firefox

This will force quit all instances of Firefox. Very handy when an app is totally frozen.

Signals Aren’t Just for Crashing Things

Not all signals are bad news! Some are meant to help programs behave better. For example:

SIGHUP can make a server re-read its config file without stopping
SIGSTOP and SIGCONT let you pause and resume tasks at will

It’s like having a remote control for your apps—you just need to know which button to press.

Conclusion

Signals are one of those Linux features that feel magical once you understand them. With just a few simple commands, you can take control of runaway processes, gently stop services, or automate routine tasks.

It may take a little practice, but once you get comfortable using process signals, you'll feel way more in control of your Linux system.

Want a quick cheat sheet or an example script that automates some of this? I'm happy to help. Just say the word.

Linux Communication Commands Every System Administrator Should Know: `users`, `write`, and `wall`

Alexand — Mon, 09 Jun 2025 08:18:20 +0000

1. users – Who’s Logged In?
2. write – Sending Private Messages to Users
3. wall – Broadcasting Messages to All Users
Conclusion

In a Linux environment, especially one shared by multiple users, effective communication between system administrators and logged-in users is essential. Whether notifying users about system maintenance, sending a private message, or broadcasting an urgent alert, Linux provides several built-in tools to facilitate smooth communication.

Three fundamental commands for user interaction are users, write, and wall. Understanding how these commands work can help administrators manage their systems efficiently while ensuring users stay informed.

Let’s explore each command, why they matter, and how they can be used in real-world scenarios.

1. `users` – Who’s Logged In?

The users command provides a simple way to check which users are currently logged into the system. It displays a list of active users based on session data.

Why is it useful?

Helps administrators identify who is actively using the system.
Useful for monitoring user presence before sending important system messages.
Quick and easy way to verify multiple active users.

Example Usage:

users

Example output:

alice bob admin

This means three users (alice, bob, and admin) are currently logged in.

Use Case:

Before restarting a server or performing maintenance, an administrator can run users to see who is online and notify them accordingly.

2. `write` – Sending Private Messages to Users

The write command allows administrators to send direct messages to specific logged-in users. This is useful when you need to communicate individually rather than broadcasting to everyone.

Why is it useful?

Enables one-on-one communication between users.
Useful for sending urgent messages privately.
Ideal for notifying a single user about system issues or warnings.

Example Usage:

write bob

After typing the command, the administrator can enter a message, like:

Hello Bob, we are restarting the server in 5 minutes. Please save your work.

Once the message is complete, pressing Ctrl + D sends it to the recipient.

Use Case:

An administrator notices that bob is running an important process and needs a warning before system shutdown. They send him a message using write to notify him privately.

3. `wall` – Broadcasting Messages to All Users

The wall (short for "write all") command lets administrators send a message to all logged-in users at once. This is great for urgent announcements or maintenance alerts.

Why is it useful?

Broadcasts messages to everyone logged into the system.
Ideal for system-wide notifications.
Ensures users receive critical updates instantly.

Example Usage:

wall "System maintenance starts in 10 minutes. Please log out."

All users will see the message displayed on their terminals.

Use Case:

Before shutting down the system for updates, an administrator uses wall to ensure every user sees the notification.

Conclusion

Clear communication between system administrators and users is a key part of managing a Linux system. The users, write, and wall commands help administrators monitor logged-in users and send both private and public messages effectively.

Whether you’re warning users about upcoming maintenance, messaging an individual about an issue, or keeping track of active sessions, these commands simplify communication and enhance system management.

Mastering them ensures smoother operations and fewer disruptions for everyone using the system.

Mastering User Monitoring in Linux

Alexand — Sun, 08 Jun 2025 11:45:04 +0000

1. who – Checking Active Users in Real-Time
2. last – Reviewing User Login History
3. w – Monitoring User Activity
4. id – Understanding User Identity and Permissions
Conclusion

In the dynamic world of Linux system administration, monitoring user activity is crucial for security, system integrity, and overall efficiency. Whether you’re managing a corporate server, a personal workstation, or a multi-user environment, knowing who is logged in, what they are doing, and their access privileges can help prevent unauthorized usage, identify potential security risks, and streamline system performance.

Imagine running a Linux server with multiple users, some accessing files, others executing critical processes, and a few perhaps trying something suspicious. How do you keep track of who’s online, when they logged in, what commands they are running, and what permissions they have? Fortunately, Linux provides powerful built-in commands to help administrators monitor user activity effectively.

In this article, we'll explore four essential commands: who, last, w, and id. These tools give you insight into current and past user sessions, helping you maintain control over your system while ensuring security and efficiency.

1. `who` – Checking Active Users in Real-Time

The who command is your go-to tool for quickly identifying users currently logged into the system. Think of it as a live dashboard displaying real-time user activity.

Why is it useful?

Tracks logged-in users in real-time.
Assists in system troubleshooting.
Essential for security audits.

Example Usage:

who

Typical output:

user1     pts/0    2025-06-08 12:45
admin     pts/1    2025-06-08 12:50

This output tells us that two users (user1 and admin) are actively connected to the system.

2. `last` – Reviewing User Login History

The last command provides historical data about previous logins, offering insights into when users accessed the system and from where.

Why is it useful?

Helps detect suspicious login attempts.
Useful for auditing user activity.
Assists in troubleshooting access issues.

Example Usage:

last

Example output:

user1     pts/0    2025-06-07 18:30   still logged in
admin     pts/1    2025-06-07 17:45   1h 30m

Here, we see that user1 logged in yesterday and is still online, while admin accessed the system for 1 hour and 30 minutes before logging out.

3. `w` – Monitoring User Activity

Unlike who, the w command doesn’t just show logged-in users—it also displays their ongoing tasks and system resource consumption.

Why is it useful?

Helps track real-time system usage.
Identifies resource-heavy processes.
Useful for diagnosing system performance issues.

Example Usage:

Example output:

USER    TTY      FROM      LOGIN@  IDLE  JCPU  PCPU  WHAT
user1   pts/0    192.168.1.5 12:45  10:05  0.45s  0.30s  vim test.py
admin   pts/1    192.168.1.10 12:50  00:10  1.20s  0.80s  top

Here, user1 is editing a Python script using vim, while admin is monitoring system processes using top.

4. `id` – Understanding User Identity and Permissions

The id command gives vital information about user IDs and group memberships, helping administrators manage user privileges.

Why is it useful?

Verifies user identity and permissions.
Essential for managing access rights.
Helps troubleshoot user restrictions.

Example Usage:

id

Example output:

uid=1001(user1) gid=1001(user1) groups=1001(user1),27(sudo)

This output shows that user1 belongs to the sudo group, meaning they have administrative privileges.

Conclusion

System administrators play a vital role in ensuring Linux systems run smoothly and securely. The commands who, last, w, and id empower administrators with crucial insights into user activity, enabling them to monitor login sessions, track resource usage, and manage access permissions efficiently.

By mastering these commands, you can enhance security, optimize system performance, and gain better control over your Linux environment. Whether you’re troubleshooting issues, preventing unauthorized access, or simply keeping an eye on system usage, these tools are invaluable for maintaining a robust and well-managed Linux system.

Copying Files to a Remote Server with SCP on Linux A Simple Guide for Everyone

Alexand — Fri, 06 Jun 2025 17:03:19 +0000

Ever needed to transfer files between your local machine and a remote server? If you're working with Linux, the scp (Secure Copy) command is a lifesaver. It's quick, secure, and built into most Linux distributions. In this article, we'll break down how to use scp, why it’s useful, and how it works—all in simple English, so even if you're new to Linux, you’ll get it!

What Is SCP?

SCP stands for Secure Copy Protocol. It allows you to transfer files between computers using SSH (Secure Shell), ensuring security during transmission. It works just like the regular cp command, but instead of copying files locally, it sends them over a network to a remote machine.

Why SCP?

Secure: Uses SSH encryption to protect your data.
Simple: No need for additional software.
Fast: Works efficiently even with large files.

Real-Life Use Case

Imagine you’re a developer working on a website. You’ve finished coding on your local machine, and now you need to transfer your files to a remote server so users can access your site. Instead of using a slow web upload, you can quickly and securely copy your files using SCP.

Another common example is backing up important data; you might want to send your personal documents to a remote server for safekeeping without relying on cloud services.

How to Use SCP

1️⃣ Copy a File from Local to Remote

To send a file (myfile.txt) to a remote server, use this command:

scp myfile.txt username@remote_host:/path/to/destination/

Breaking it down:

scp → The command itself
myfile.txt → The file you want to send
username@remote_host → Your SSH login (change "username" to your actual remote username and "remote_host" to the server's address)
/path/to/destination/ → The folder where you want the file to be placed

After running this command, SCP will prompt you to enter your password for the remote server. Once entered, the file will be transferred securely!

2️⃣ Copy a File from Remote to Local

To bring a file (remotefile.txt) from a remote server back to your local machine, use:

scp username@remote_host:/path/to/remotefile.txt /local/destination/

This does the opposite—it retrieves the file instead of sending it.

3️⃣ Copy a Directory

Need to send a whole folder? Use -r (recursive mode):

scp -r myfolder username@remote_host:/path/to/destination/

This transfers all files inside myfolder to the remote server.

Tips for Smooth Transfers

✔️ Check SSH Access: Make sure you can connect to the remote server via SSH before using SCP.

✔️ Use Absolute Paths: Be clear about where your files should go on the remote system.

✔️ Speed It Up: Add -C for compression to speed things up when transferring large files.

scp -C myfile.txt username@remote_host:/path/to/destination/

✔️ Use SSH Keys: If you transfer files often, set up SSH keys so you don’t have to enter passwords every time.

Conclusion

SCP is one of the simplest yet most effective tools for transferring files securely between computers. Whether you're a developer, system administrator, or just someone backing up personal files, knowing how to use SCP can save you time, effort, and frustration.

Give it a try and see how effortlessly you can move your files!

Understanding Special Permissions in Red Hat Linux (Simple Guide for Beginners)

Alexand — Thu, 29 May 2025 08:44:15 +0000

Introduction: Why Special Permissions Matter
What Are Special Permissions in Linux?
1. Setuid (SUID) – Running a Program as the File Owner
- What does it do?
- Why is it useful?
- Example: The ‘passwd’ Command
- How to Set SUID on a File
2. Setgid (SGID) – Running a File as Its Group
- What does it do?
- Why is it useful?
- Example: Shared Directories for Developers
- How to Set SGID on a Directory
3. Sticky Bit – Protecting Files in Shared Directories
- What does it do?
- Why is it useful?
- Example: Securing the /tmp Directory
- How to Set Sticky Bit on a Directory
Use Cases for Special Permissions in Linux
Final Thoughts

Introduction: Why Special Permissions Matter

Imagine you’re working on a shared Linux system, and you want to control who can access certain files, what they can do, and how security is enforced. In Linux, special permissions help prevent unauthorized access, protect critical files, and improve system security.

If you’ve ever wondered why some files require extra permissions, or why certain scripts can run even when a user doesn’t own them, this guide will break down everything in simple terms. Let’s explore setuid, setgid, and the sticky bit—the three special permissions in Red Hat Linux—and their real-world use cases!

What Are Special Permissions in Linux?

Linux normally uses basic permissions:

Read (r) → Can view a file.
Write (w) → Can modify a file.
Execute (x) → Can run a file/program.

But sometimes, you need special permissions to handle important files in a secure way. These special permissions include:

✅ Setuid (SUID) → Allows a file to run with the privileges of its owner.

✅ Setgid (SGID) → Allows a file/folder to run with the privileges of its group.

✅ Sticky Bit → Protects files in shared directories from accidental deletion.

These special permissions help system administrators, developers, and users manage important files and programs safely.

1. Setuid (SUID) – Running a Program as the File Owner

What does it do?

When the SUID (set user ID) permission is enabled, a file runs with the privileges of its owner, instead of the user executing it.

Why is it useful?

Some programs need special access to system resources, but you don’t want to give users complete administrative power. SUID helps with this.

Example: The ‘passwd’ Command

Linux users change passwords with the passwd command. But password information is stored in a system file that only the root user can modify.

To allow regular users to update their passwords without full root access, the passwd command has SUID enabled.

Check its permissions with:

ls -l /usr/bin/passwd

You’ll see something like this:

-rwsr-xr-x 1 root root 27544 Mar 19 15:30 /usr/bin/passwd

Notice the ‘s’ in rwsr-xr-x. That means SUID is enabled, allowing users to run passwd with root privileges only for changing passwords—nothing else.

How to Set SUID on a File

If you want a script to always run with its owner's privileges, use this command:

sudo chmod u+s myscript.sh

This means any user running myscript.sh will execute it with the owner’s permissions.

2. Setgid (SGID) – Running a File as Its Group

What does it do?

Setgid (set group ID) makes sure that when a user runs a file, it runs with the permissions of the file’s group instead of their own.

Why is it useful?

This helps teams working on shared projects—everyone in a specific group can automatically inherit permissions to files and directories.

Example: Shared Directories for Developers

Imagine a team of developers working on a project. You want them all to have permission to edit files inside a folder, but without manually setting permissions for each file.

You can apply SGID to the folder, so that all new files inside it automatically inherit group permissions.

How to Set SGID on a Directory

Run this command on a shared folder:

sudo chmod g+s /home/dev_team

Now, every new file inside /home/dev_team will inherit the group’s permissions, making collaboration easier.

3. Sticky Bit – Protecting Files in Shared Directories

What does it do?

A sticky bit prevents users from deleting files they don’t own, even if they have write access to the directory.

Why is it useful?

Sticky bits are mainly used in public/shared folders, like /tmp, where multiple users store files. This prevents accidental or malicious deletion of important files.

Example: Securing the /tmp Directory

The /tmp folder in Linux is accessible to everyone, meaning users can store temporary files there. However, if sticky bit wasn't enabled, any user could delete anyone else’s files inside /tmp.

That’s why Linux sets the sticky bit by default on /tmp, ensuring users can delete only their own files.

Check its permissions with:

ls -ld /tmp

You’ll see something like this:

drwxrwxrwt 17 root root 4096 Mar 19 15:30 /tmp

Notice the ‘t’ at the end of drwxrwxrwt—that means the sticky bit is enabled.

How to Set Sticky Bit on a Directory

If you have a shared folder where users should only delete their own files, enable the sticky bit:

sudo chmod +t /shared_folder

Now, users can’t remove files they don’t own, even if they have write permissions for the folder.

Use Cases for Special Permissions in Linux

✅ Allow regular users to run important system commands safely (SUID on passwd).

✅ Manage shared projects where all team members need equal access (SGID on project folders).

✅ Protect files in public directories from accidental deletion (Sticky bit on /tmp).

System administrators, developers, and general users all benefit from special permissions—they make Linux more secure, efficient, and easy to manage.

Final Thoughts

Special permissions in Red Hat Linux aren’t just for experts—once you understand how SUID, SGID, and sticky bit work, you’ll appreciate how they improve security and simplify file management.

Try using these permissions on test files, experiment with shared folders, and soon enough, you’ll master Linux file security like a pro! 🚀

DEV Community: Alexand

The DevOps Mindset Operating System

📌 Table of Contents

Why Mindset Comes Before Tools

1. Long‑Term Compounding

2. Identity Transformation

3. High Professional Standards

4. Systematic Productivity

The Engineering Mindset: Think Like a Builder

Why Motivation Fails (and Systems Don’t)

1. You Stop Letting Emotions Control Your Day

2. You Benefit from Compounding

3. You Reduce Friction with Smart Routines

4. You Avoid “Performance Leaks”

5. You Stay Accountable Through Measurement

Your Personal Operating System

Final Thought

Behind the Scenes of Your Files: Why Inodes Are the Real Story in Linux

What’s an Inode?

Hard Links: Multiple Labels, One File

Soft Links: A Shortcut with Limits

Why Inodes Matter

How to See Inodes in Action

How to Enable Virtualization in BIOS/UEFI — A Step-by-Step Guide for Cloud Learners

What Is Virtualization and Why You Need It

How to Check If Virtualization Is Enabled

Steps to Enable Virtualization in BIOS/UEFI

Step 1: Restart Your Computer

Step 2: Enter BIOS/UEFI

Step 3: Find Virtualization Settings

Step 4: Enable It

Step 5: Confirm It’s Working

What’s Next?

Work Smarter with Tmux in Red Hat Linux — Keep Your Terminal Tasks Safe and Organized

📚 Table of Contents

What Tmux Can Do

Why Tmux Is Handy

Example You Can Try

Useful Tmux Commands

How to Install Tmux

Wrap-Up

AutoFS in Red Hat Linux — Let Your System Mount Drives Without You Askin

What AutoFS Does

Why It Helps

Simple Example

How to Set It Up

Test It

Keyboard Kung Fu — Mastering CTRL Commands in the Red Hat Linux Terminal

🧹 CTRL + U — Clear the Line

❌ CTRL + C — Cancel the Current Command

💤 CTRL + Z — Pause a Process (Send to Background)

🧤 CTRL + D — End of Input / Exit Terminal

🧠 Real-Life Mini Scenario

🧩 Final Thought

Is Your System Talking Back? A Guide to Red Hat Linux Monitoring Tools

Table of Contents

Why Monitoring Matters

Essential Monitoring Commands (And How to Actually Use Them)

1. top

2. htop (if installed)

3. vmstat

4. iostat

5. netstat

6. df -h

7. du -sh

Real-World Monitoring Scenario

Final Word

Understanding Process Signals in Linux

What Is a Process Signal?

Real-Life Use Case

Common Process Signals You Should Know

How to Send a Signal Using kill

Using killall for Convenience

Signals Aren’t Just for Crashing Things

Conclusion

Linux Communication Commands Every System Administrator Should Know: `users`, `write`, and `wall`

Table of Contents

1. users – Who’s Logged In?

Why is it useful?

Example Usage:

🧹 `CTRL + U` — Clear the Line

❌ `CTRL + C` — Cancel the Current Command

💤 `CTRL + Z` — Pause a Process (Send to Background)

🧤 `CTRL + D` — End of Input / Exit Terminal

1. `top`

2. `htop` (if installed)

3. `vmstat`

4. `iostat`

5. `netstat`

6. `df -h`

7. `du -sh`

How to Send a Signal Using `kill`

Using `killall` for Convenience

1. `users` – Who’s Logged In?

2. `write` – Sending Private Messages to Users

3. `wall` – Broadcasting Messages to All Users

1. `who` – Checking Active Users in Real-Time

2. `last` – Reviewing User Login History

3. `w` – Monitoring User Activity

4. `id` – Understanding User Identity and Permissions