DEV Community: Alex Enson

Scripting Series – Part 8 of 8

Alex Enson — Tue, 06 May 2025 12:24:24 +0000

In the final part of the scripting series, we will be a looking at a real world example of a system health script you can run in your production environment.

This type of script is a powerful tool for both new and seasoned Linux users, offering a quick and automated snapshot of a system's health. It combines key administrative tasks - like checking uptime, disk usage, system load, user activity, and log data - into a single, readable report. Whether you're a student learning Bash, a sysadmin managing servers, or a DevOps engineer monitoring resources, this script saves time, reduces manual effort, and builds a habit of proactive system checks. It’s not just a script - it’s a hands-on learning experience and a real-world productivity booster.

Create the script in VIM.

Write the script in VIM and save it.

Save the script.

The tee command in Linux is used to read from standard input and write to both standard output and one or more files simultaneously. It's especially useful when you want to see the output of a command on the screen but also save it to a file.

This is a well-organized Bash script designed to generate a system health report and log it to a timestamped file. Below is a breakdown of the script section by section, along with explanations of the commands and their purposes.

Description of what is happening in the script:

🧾 1. Define Variables
LOG_DIR="$HOME/sys_logs"
DATE_STR=$(date +%F_%H-%M-%S)
LOG_FILE="$LOG_DIR/report_$DATE_STR.log"
HOSTNAME=$(hostname)
CURRENT_USER=$(whoami)
• LOG_DIR: Sets the directory where logs will be stored.
• DATE_STR: Gets current date and time in YYYY-MM-DD_HH-MM-SS format.
• LOG_FILE: Constructs the full path of the log file.
• HOSTNAME, CURRENT_USER: Capture system hostname and the user running the script.

📁 2. Prepare Directory and Log File
mkdir -p "$LOG_DIR"
touch "$LOG_FILE"
• Ensures the log directory exists, and creates an empty log file.

🖥 3. System Info
Prints basic system information like:
• Current user
• Hostname
• Home directory
• Default shell
• Current $PATH
All outputs are shown on-screen and saved to the log file using tee -a.

⏳ 4. System Uptime
uptime -p | tee -a "$LOG_FILE"
• Shows how long the system has been running in human-readable form.

💾 5. Disk Usage
df -h | grep -v tmpfs | tee -a "$LOG_FILE"
• Displays disk usage excluding tmpfs (temporary filesystems).

📂 6. Top 5 Largest Directories in /
du -ah / 2>/dev/null | sort -rh | head -n 5 > /tmp/top_dirs.tmp
cat /tmp/top_dirs.tmp | tee -a "$LOG_FILE"
• Lists the 5 largest files/directories starting from root.
• Redirects errors (e.g. permission denied) to /dev/null.

👥 7. Math with expr (User Count)
total_users=$(who | wc -l)
users_plus_five=$(expr $total_users + 5)
• Counts logged-in users.
• Adds 5 to that count using expr.

🔢** 8. Math with (( )) (Log Files Count)**
log_count=$(ls -1 /var/log | wc -l)
log_times_three=$(( log_count * 3 ))
• Counts how many files are in /var/log.
• Multiplies that count by 3 using arithmetic expansion.

🧮 9. Floating-point Math with bc (Load Average)
load_string=$(cat /proc/loadavg)
load1=$(echo "$load_string" | cut -d ' ' -f1)
load5=$(echo "$load_string" | cut -d ' ' -f2)
avg_load=$(echo "scale=2; ($load1 + $load5)/2" | bc)
• Gets CPU load averages (1 and 5 minute).
• Calculates their average using bc, which handles floating-point math.

✅ 10. Exit Status Check
ls /etc/passwd > /dev/null
status=$?
• Runs a harmless command and captures its exit status.
• Useful for testing if commands succeed (status 0) or fail (non-zero).

🏁 11. Script Exit
exit 0
• Clean exit from the script, signaling success.

✅ Key Concepts Demonstrated
• Variables and string substitution
• Date formatting
• File and directory operations
• Redirection and piping
• Use of tee to log and display output
• Integer and floating-point math
• Process status ($?)
• Basic use of utilities like df, uptime, du, bc

Apply the necessary permission to the script so it can be executed.

If we do a ls –ltrh we see that the script has been created and also it is in green colour – meaning the permissions have been applied to the script and therefore it is now executable.

Execute the script with ./

Output of the script once it has been executed.

Following the execution of the script, a directory has been created with log files.

Let’s go into the directory.

If we do a ls –ltrh and see what is inside the directory.

We can see that a log file has been created following the execution of the script.

If we were to go into the log file with VIM, it basically displays the same information as the output – following the execution of the script.

Connect with me on LinkedIn

#30DaysLinuxChallenge #RedHatEnterpriseLinux
#CloudWhistler #CloudEngineer #Linux
#DevOps #RedHat #OpenSource
#CloudComputing #Automation
#CloudEngineer #SysAdmin #ITSecurity #TechTips #BusinessIT #Leadership

Scripting Series – Part 7 of 8

Alex Enson — Mon, 05 May 2025 11:24:25 +0000

Here we will dive into part 7 in the shell scripting series. Today we will be looking at two scripts in order to check whether a particular service is running.

Shell scripting is essential in production environments for automating repetitive tasks, ensuring consistency, and minimising human error. It enables engineers to streamline deployments, manage system configurations, monitor processes, and orchestrate complex workflows with precision. In a high-availability environment, shell scripts act as reliable, lightweight tools that reduce manual intervention and improve operational efficiency.

1st Script:

Create the script in VIM.

Write the script in VIM and save it.

✅ What it does:
• ls "$logfile": Tries to list the file whose path is in the variable logfile.
• 2>/dev/null: Suppresses error messages by redirecting stderr (file descriptor 2) to /dev/null.
💡 In Plain English:
“Try to list this file. If it doesn’t exist, don’t show any error message.”
🧠 Common use in scripts:
This is often used to check if a file exists without showing errors.

Apply the necessary permissions to the script so it can be executed.

If we do a ls –ltrh we see that the script has been created and also it is in green colour – meaning the permissions have been applied to the script and therefore it is now executable.

Execute the script with ./

Output of the script once it has been executed.
The script confirms that the SSHD service is running, however there are no logs , so therefore none are displayed.

2nd Script:

Create the script with VIM.

Write the script in VIM and save it.

The --quiet option in systemctl is-active --quiet means:
Suppress all output — the command returns only an exit status, with no text output.
Here's how it works:
• Exit status 0 → The service is active/running.
• Exit status 1 or other non-zero → The service is inactive, failed, or not found.

Apply the necessary permissions to the script so it can be executed.

If we do a ls –ltrh we see that the script has been created and also it is in green colour – meaning the permissions have been applied to the script and therefore it is now executable.

Execute the script with ./

Output of the script once executed.

Stay tuned, part 8 in the series coming tomorrow!

Scripting Series – Part 6 of 8

Alex Enson — Sun, 04 May 2025 12:09:03 +0000

Here we will dive into part 6 in the shell scripting series. Today we will look at how you can use a for loop to iterate through all files in a directory and the function of file comparison.

Create the script using VIM.

Write the script in VIM and save the file.

Apply the necessary permissions to the script so it can be executed.

If we do a ls –ltrh we see that the script has been created. It has a green colour to it – indicating that it is now executable.

Execute the script using ./

The output of the script, after it has been executed.

Stay tuned, part 7 in the series coming tomorrow!

Scripting Series – Part 5 of 8

Alex Enson — Sat, 03 May 2025 12:23:22 +0000

Let's continue our shell scripting series in Linux.

Today we will be looking at the 'Continue'command and the use cases for this command to be used in your script.

In Linux shell scripting, the continue command is used inside loops (like for, while, or until) to skip the rest of the current iteration and move on to the next one.

🔁 How it works:
• When continue is hit, the script jumps straight to the next loop cycle, bypassing any remaining commands in the current iteration.

🔧 IT Use Case: Skipping Certain Files During Batch Processing
Scenario: A system administrator writes a script to scan a directory and apply security patches or audits to all .sh files, but wants to skip any files with the word test in the filename.

Benefit: This ensures that test scripts are excluded from production-level audits, reducing risk and processing time. It makes the automation cleaner and more intelligent.

💼 Business Use Case: Processing Customer Records and Skipping Inactive Accounts
Scenario: A business analyst creates a shell script to analyze customer records from a CSV file. The analyst wants to skip rows where the status is inactive.

Benefit: The script saves time and resources by ignoring irrelevant data, ensuring the analysis focuses only on engaged customers. This improves marketing targeting and ROI calculations.

The -r option in the read command in Bash stands for "raw", and it prevents backslashes () from being interpreted as escape characters.

💡 When to Use -r?
Always use -r unless you explicitly want to interpret escape sequences like \n, \t, or \. It's especially important when reading file paths, raw strings, or data from CSV files to avoid unexpected transformations.

Create the script in VIM.

Write the script in VIM and save it.

Apply the necessary permissions, so the script can be executed.

If we do a ls –ltrh we can confirm that the script has been created and the execute permissions has been applied to it, as it is in green colour.

Execute the script with ./

Output after executing the script.

You can say that only the false statements are displaying, not the true statements.

Stay tuned, part 6 in the series coming tomorrow!

Scripting Series – Part 4 of 8

Alex Enson — Fri, 02 May 2025 10:48:20 +0000

Welcome to part 4 in the series of shell scripting. Today we will look at a script that goes through an array with complex values. Complex values such as spaces, apostrophes, and quotes.

Scripting is the process of writing a set of instructions in a programming or scripting language to automate tasks that would otherwise be done manually. In the context of shell scripting, these instructions are written for the command-line shell, allowing users to perform complex operations - like file management, backups, or software installations - with just a single script execution. It's a powerful tool for saving time and ensuring consistency in system administration and development workflows

Create the script in VIM, complex_list.sh

Write and save the script in VIM.

We can check whether it has been created by doing ls -ltrh.

Give the permission so the script can be executed.

If we then do a ls –ltrh we can see the script has gained a green colour, meaning that it is now executable.

Output after executing the script by using the command ./

Stay tuned, part 5 in the series coming tomorrow!

Scripting Series – Part 3 of 8

Alex Enson — Thu, 01 May 2025 10:44:55 +0000

We will continue our scritpting series - with part 3 in the series.

Here we will look at a script that breaks out of a for loop.

Shell scripting in Linux is essential for automating repetitive tasks, streamlining system administration, and boosting productivity. It allows users to create powerful scripts that manage files, schedule backups, monitor system health, and more—all with simple, readable code. This makes shell scripting a key skill for anyone working with Linux.

Create the script in Vim.

Write the script and save it.

Apply the necessary permissions to the script so you can execute it.

Execute the script and you will get the output.

Stay tuned, part 4 in the series coming tomorrow!

Scripting Series – Part 2 of 8

Alex Enson — Wed, 30 Apr 2025 09:41:12 +0000

In the Linux environment, scripting is a fundamental practice that empowers users and administrators to automate repetitive tasks, streamline workflows, and ensure consistency across systems.

The scripting series continues and today we will look at whether you can run a specific scipt.

Open VIM and name thefile you want to create.

In VIM write the script and save the file.

Check whether the script has been created and we can see it has.

Give the script the correct permissions so we can execute it.

Run the script.

Output, and we see that we are not allowed to run the particular file.

Stay tuned, part 3 in the series coming tomorrow!

Scripting Series – Part 1 of 8

Alex Enson — Tue, 29 Apr 2025 12:48:30 +0000

🔧 Introduction to Linux Scripting: Automate Like a Pro
Ever wish your computer could handle repetitive tasks for you-like cleaning up files, backing up data, or monitoring systems? That’s where Linux scripting comes in! With just a few lines of shell script, you can turn manual chores into automated magic.

Linux scripting uses the Bash shell (or similar) to create simple programs-called shell scripts-that can execute commands, control logic, and interact with files. It’s like giving your terminal a brain and a to-do list!

Whether you're a system admin, developer, or just someone who wants to save time, Linux scripting is your entryway to working smarter, not harder.

When making a script – the extension has be .sh for shell. So the system recognises that the script contains shell commands that will be executed.

The .sh extension in a script stands for "shell script." It's a convention commonly used for scripts written for Unix-like operating systems (like Linux and macOS) that are intended to be executed by a shell (such as Bash or Zsh). The extension indicates that the file contains shell commands, but it's not mandatory for the script to work. It's mainly used for organization and clarity.

Basic While Loop Script

Create the script in Vim.

If we do a ls –ltrh we see the script has been created.

If we do not give the right permissions to execute the script, then we will get denied.

In Linux, we give execute permissions to users in order to run a script.

There are three categories of users who can be given permissions:
Owner (user) – The person who created the file or owns it.
Group – A group of users that share the same permissions.
Others – Everyone else who is not the owner or in the group.

Output:
To execute the script we have to use ./ then the name of the script

To run a script on Linux, you typically need to give it execute permissions. This can be done using the chmod command.
Here’s how you can do it:

Open your terminal.
Navigate to the directory where the script is located.
Run the following command to give the script execute permissions: chmod +x script_name.sh

chmod 755 (name of the script)
You can also use chmod +x to grant execute permissions without specifying numeric values like 755. The command chmod +x simply adds execute permission to the script for the user.
However, if you want to give the script read, write, and execute permissions to the owner and only execute permissions to others, then chmod 755 would be appropriate. But since you're asking to avoid that, chmod +x is the simpler and more common choice.

Stay tuned, part 2 in the series coming tomorrow!

Linux Boot Process

Alex Enson — Mon, 28 Apr 2025 13:07:04 +0000

🖥️ Understanding the Linux Boot Process: From Power-On to Desktop.

Introduction

Have you ever wondered what really happens the moment you press the power button on your Linux machine?
Behind the scenes, a fascinating journey unfolds — a series of well-orchestrated steps that bring your system to life.
Whether you're an IT pro, a business leader, or just a tech enthusiast, understanding the Linux booting process can give you powerful insights into system security, performance, and troubleshooting.
Let’s dive into the magic that happens in those precious few seconds! 🚀

Index

1.What is UEFI?
2.The Role of POST (Power-On Self-Test)
3.BIOS vs UEFI Booting
4.The Role of LILO (Linux Loader)
5.How systemd Powers Up Your System
6.Real-world Use Cases (IT and Business)
7.Summary

1.What is UEFI?

UEFI stands for Unified Extensible Firmware Interface — the new superstar replacing traditional BIOS.
It offers faster boot times, stronger security (hello, Secure Boot! 🔒), and a more modern interface for system management.
Fun fact: Thanks to UEFI, your computer can boot in seconds instead of minutes!

2. The Role of POST (Power-On Self-Test)

POST is your system’s first line of defense.
When you power on your machine, POST quickly checks if your hardware — like RAM, keyboard, or hard drives — is functioning properly.
👉 If POST finds a problem, it will display an error message on your screen — saving you from deeper troubleshooting nightmares.

3. BIOS vs UEFI Booting

• BIOS Booting:
The bootloader (the little program that starts the OS) lives in the Master Boot Record (MBR) — the very first sector of your hard drive.
• UEFI Booting:
A more modern approach where bootloaders live in a special area called the EFI System Partition.
UEFI also supports larger drives and faster startup.
Customization Tip: UEFI settings are flexible and can be customized to your preferences — such as boot order or enabling/disabling Secure Boot.

4. The Role of LILO (Linux Loader)

LILO stands for Linux Loader — a classic bootloader from the early Linux days.
While it's less commonly used today (GRUB is more popular), LILO paved the way for flexible, multi-OS booting options.

5. How systemd Powers Up Your System

Once your kernel starts, systemd takes over.
It’s like the conductor of a tech orchestra, handling:
• Power management 🎛️ (like sound and battery controls)
• User authentication and logins 🧑💻
• Starting your desktop environment (GNOME, KDE, etc.)
Without systemd, your system wouldn’t know how to "wake up" into a usable, graphical world.

6. Real-world Use Cases (IT and Business)

IT Perspective:
• Knowing how boot works helps with faster troubleshooting (e.g., diagnosing hardware failures or bootloader corruption).
• Mastery over UEFI/BIOS settings is critical when deploying new machines in enterprise environments.
Business Perspective:
• Faster, more secure booting means less downtime, better device security, and a smoother user experience for employees.
• With Secure Boot via UEFI, businesses strengthen their defense against malware that tries to tamper with the boot process.

Summary

The Linux booting process — from POST checks to systemd orchestration — is a beautiful choreography of software and hardware working in perfect harmony.
Understanding these steps doesn’t just make you a smarter IT professional — it empowers you to make better decisions around system design, security, and performance.
The next time you boot your machine, you’ll know exactly what's happening under the hood.
Pretty cool, right? 🚀

Stay tuned for more upcoming content!

Connect with me on LinkedIn

#30DaysLinuxChallenge #RedHatEnterpriseLinux
#CloudWhistler #CloudEngineer #Linux
#DevOps #RedHat #OpenSource
#CloudComputing #Automation
#CloudEngineer #SysAdmin #ITSecurity #TechTips #BusinessIT #Leadership

How to Reset the Root Password on Linux (Safely and Easily)

Alex Enson — Sun, 27 Apr 2025 15:02:34 +0000

Introduction

When you lose your root password, it can feel like being locked out of your own digital home. Don't worry—I'm here to guide you through the most practical methods to reset your root password safely. We'll cover multiple approaches, and I'll highlight real IT and business scenarios where each method shines!

Important First Step: Before trying any of these methods, take a snapshot or backup of your system. If anything goes wrong, you’ll be grateful you did! Here's a helpful video that shows you how: How to take a snapshot on Oracle VM.

Index

• Method 1: Quick Edit at Boot (Easy Mode)
• Method 2: Remount Filesystem as Read/Write
• Method 3: Use the End Key Trick
• Method 4: SELinux Considerations

Method 1: Quick Edit at Boot (Easy Mode)
Steps:

1.Reboot your system.
2.As soon as it starts booting, press e to edit the boot parameters.
3.Find the line starting with linux or linux16.
4.At the end of the line, add the following:

init=/bin/bash

5.Press Ctrl + X to boot.
6.You'll now have root access in single-user mode.
7.Set a new root password with:
passwd
8.Reboot the system.

Use Case:
• IT Admins needing a fast recovery during scheduled maintenance.
• Business: Quick password resets with minimal downtime in non-production environments.

Method 2: Remount Filesystem as Read/Write

Steps:
1.Follow the same steps as Method 1 to enter edit mode and boot into /bin/bash.

2.Once you land in the shell, remount the filesystem with write permissions:

mount -o remount,rw /

3.Then change the root password:
Passwd

4.Finally, reboot the system.

Use Case:
• IT Professionals recovering production systems.
• Business: Essential for critical servers where the filesystem is initially in read-only mode to prevent accidental corruption.

Method 3: Use the End Key Trick
Steps:
1.On boot, press e.

2.Use the End key to jump directly to the end of the kernel line.
3.Add:

rd.break

4.Press Ctrl + X to continue booting.
5.At the switch_root prompt:
6.mount -o remount,rw /sysroot

7.chroot /sysroot
8.passwd
9.touch /.autorelabel

10.exit and
exit again

Use Case:
• Advanced Users who need a deeper recovery without compromising SELinux labeling.
• Business: Helps ensure compliance on secure systems where SELinux contexts must remain intact.

Method 4: SELinux Considerations.
If SELinux is enforcing, resetting the password could lock you out after reboot. Here's how to deal with that:
Important Tips:
• If SELinux is set to permissive, you're good! No additional steps needed.
• If it's enforcing, you must trigger a relabel:

touch /.autorelabel

Why does this matter? When SELinux is in enforcing mode, it checks file security contexts very strictly. Resetting the password without proper relabeling could deny root access even after setting a new password.
Use Case:
• SysAdmins in highly regulated industries (finance, healthcare).
• Business: Ensures compliance with strict security policies and prevents post-reset access issues.

Summary
Resetting your Linux root password isn't as scary as it sounds - if you follow the right process. Always back up your system first, and pick the method that best suits your environment and urgency. Whether you're managing a personal project or a critical enterprise server, mastering these recovery tricks is a must-have skill in your admin toolkit.
Stay safe, stay backed up, and happy hacking!

Connect with me on LinkedIn

Stay tuned for more upcoming content!

#30DaysLinuxChallenge #RedHatEnterpriseLinux
#CloudWhistler #CloudEngineer #Linux
#DevOps #RedHat #OpenSource
#CloudComputing #Automation
#CloudEngineer #SysAdmin #ITSecurity #TechTips #BusinessIT #Leadership

Basic, ACL & Special Permssions in Linux

Alex Enson — Sat, 26 Apr 2025 18:41:25 +0000

Introduction

Have you ever wondered how Linux keeps your business data secure, yet flexible enough for collaboration? Whether you’re an IT pro or a business leader, understanding Linux permissions is your gateway to mastering file security, compliance, and operational efficiency. Let’s unlock the secrets behind Linux permissions-making your digital world safer, smarter, and more productive!

Index

1. Basic Permissions: The Foundation of Linux Security
2. ACL Access Control List Permissions: Fine-Grained Control
3. Special Permissions: Power Tools for Advanced Scenarios
4. Summary

Basic Permissions: The Foundation of Linux Security

Use Case:
Imagine your finance team working on sensitive payroll files stored on a Linux server. You want only authorized users to view or modify these files, while others are strictly kept out. This is where basic permissions shine!

What are Basic Permissions?
Linux divides permissions into three categories:
User (u): The file’s owner
Group (g): A set of users
Others (o): Everyone else
Each can have read (r), write (w), and execute (x) permissions. This trio forms the backbone of Linux security.

Essential Commands:

Check file permissions:

ls -l <file name>

Check directory permissions:
ls -ld
Change owner:

chown <user> <file/directory>

Change group:

chgrp <group> <directory>

Change both owner and group:

chown <user>:<group> <directory>

Modify permissions (examples):

chmod o-rwx <directory>      # Remove all permissions for others
chmod g-rx <directory>       # Remove read & execute for group
chmod u-w <directory>        # Remove write for owner
chmod u+rwx <directory>      # Full permissions for owner
chmod ugo+rwx <directory>    # Full permissions for everyone
chmod ugo=r-x <directory>    # Read & execute for all

Business Impact:
Basic permissions help you enforce who can access, edit, or execute business-critical files, reducing the risk of accidental leaks or unauthorized changes.

ACL Access Control List Permissions: Fine-Grained Control

Use Case:
Suppose your marketing team needs temporary access to a confidential product launch folder, but you don’t want to change the group or global permissions. Enter ACLs for precision access!
What are ACL Permissions?
ACLs let you grant (or revoke) permissions to specific users or groups—beyond the basic owner/group/others model.
Key ACL Commands:
Check ACLs:

getfacl <directory>

Add user permission:

setfacl -m u:<username>:<permission> <directory>

Remove user permission:

setfacl -x u:<username> <directory>

Remove all ACLs:

setfacl -b <directory>

Add group permission:

setfacl -m g:<group_name>:<permission> <directory>

Remove group permission:

setfacl -x g:<group_name> <directory>

Business Impact:
With ACLs, you can empower project teams with just the right access-no more, no less. It’s flexibility without compromising security or compliance.

Special Permissions: Power Tools for Advanced Scenarios

Use Case:
Your IT team needs certain scripts to always run with administrative rights, regardless of who launches them. Special permissions like SUID, SGID, and Sticky Bit make this possible.

What are Special Permissions?
SUID (Set User ID): Executes a file with the owner's privileges.
SGID (Set Group ID): Executes a file with the group’s privileges or ensures files in a directory inherit the group.
Sticky Bit: Only the file owner can delete or rename files in a directory, even if others have write access.
Business Impact:
Special permissions are essential for shared workspaces, secure script execution, and protecting critical business directories from accidental or malicious changes.

Summary

Linux permissions are more than just IT jargon-they’re your frontline defense and your ticket to smarter collaboration. From basic permissions that keep your business data safe, to ACLs that enable agile teamwork, and special permissions for advanced control, mastering these tools transforms how your organization works and innovates.
Ready to take command of your Linux environment? Start experimenting, stay curious, and watch your business thrive with smarter security!

Special Permissions in Linux

Alex Enson — Fri, 25 Apr 2025 15:11:30 +0000

👋Introduction

Ever stumbled across strange-looking file permissions in Linux that include an "s" or a "t"? You're not alone. Welcome to the world of Special Permissions, the unsung heroes of Linux security and collaboration.
Whether you're a system admin ensuring safe execution, a DevOps engineer managing shared directories, or a business leader driving secure team productivity, understanding these permissions isn't just technical fluff; it's strategic smarts.
Let’s break them down in a way that actually makes sense and see how they solve real IT and business challenges.

📚 Index

SUID Set User ID The Key to Controlled Power
SGID Set Group ID The Secret to Seamless Collaboration
Sticky Bit The Shield Against Accidental or Intentional Deletion
Numeric Mode Mastering the Binary Behind the Magic
Summary

SUID Set User ID The Key to Controlled Power

What it does: When applied to an executable file, any user who runs it temporarily assumes the file owner's permissions.
🔧 How to set it:

chmod u+s <file>

🧹 How to remove it:

chmod u-s <file>

💼 IT Use Case:
You're managing a script that needs root-level access (e.g., password updates), but you don't want to hand out the root password. SUID lets users execute it with elevated permissions without making them root. Smart, right?
📈 Business Angle:
This enables secure automation in customer onboarding, employee provisioning, or financial processing-without compromising on control or security.

SGID Set Group ID The Secret to Seamless Collaboration

What it does: When set on a directory, new files/folders inside inherit the group ownership of the directory-not the user's group.
🔧 How to set it:

chmod g+s <directory>

🧹 How to remove it:

chmod g-s <directory>

💼 IT Use Case:
Think of a shared project folder where everyone’s uploads need to stay in the same group. SGID ensures files don’t play musical chairs with permissions. Smooth collaboration, fewer headaches.
📈 Business Angle:
Project teams-from developers to designers-can collaborate in a shared space with no permission hiccups. That’s faster delivery, less admin overhead, and happier teams.

Sticky Bit The Shield Against Accidental or Intentional Deletion

What it does: In a shared directory, only the file owner can delete their own files-even if others have write access.
🔧 How to set it:

chmod o+t <directory>

🧹 How to remove it:


chmod o-t <directory>

💼 IT Use Case:
Shared temp folders like /tmp are used by multiple users. Sticky Bit keeps user files safe from accidental (or malicious) deletion by others. Essential for multi-user systems.
📈 Business Angle:
When teams share resources on a common drive, Sticky Bit ensures individual accountability and data protection, while still keeping things open and collaborative.

Numeric Mode Mastering the Binary Behind the Magic

Want to set these special permissions quickly? Use numeric (octal) mode:

Permission	Symbol	Value
SUID	u+s	4
SGID	g+s	2
Sticky Bit	o+t	1

Combine them with your regular permission (e.g., 755) like this:
🔐 SUID Example:

chmod 4755 <file>

Adds SUID

chmod -4000 <file>

Removes SUID

👥 SGID Example:

chmod 2755 <dir>

Adds SGID

chmod -2000 <dir>

Removes SGID

🛡 Sticky Bit Example:

chmod 1755 <dir>

Adds Sticky Bit

chmod -1000 <dir>

Removes Sticky Bit

🧠 Summary

Why This Matters to You, Your Team and Your Business
Linux special permissions aren’t just a technical quirk-they’re a powerful toolset that keeps your systems secure, your teams productive, and your operations clean.

🛠 SUID: Delegate power without risk
🤝 SGID: Foster seamless group collaboration
🛡 Sticky Bit: Protect shared environments from chaos
🎯 Numeric mode: Efficient permission management for pros

Whether you're an IT leader or a business driver, this knowledge bridges the gap between technical depth and practical value.
🔥 Ready to elevate your Linux game? Drop your thoughts or questions in the comments-let’s make Linux a little less scary and a lot more empowering!

Connect with me on LinkedIn

#30DaysLinuxChallenge #RedHatEnterpriseLinux
#CloudWhistler #CloudEngineer #Linux
#DevOps #RedHat #OpenSource
#CloudComputing #Automation
#CloudEngineer #SysAdmin #ITSecurity #TechTips #BusinessIT #Leadership