DEV Community: DhavalThakar97

Linux in Action: Mastering Crontab for Task Scheduling (RHCSA & DevOps)

DhavalThakar97 — Thu, 11 Dec 2025 04:38:55 +0000

Introduction

Task automation is a core responsibility of every Linux system administrator. Whether you’re running nightly backups, rotating logs, generating reports, or triggering DevOps workflows, the cron scheduler provides a reliable and flexible way to execute recurring jobs.

This article provides a complete, RHCSA-aligned guide to using crontab, enriched with real-world business use cases and practical examples you can apply immediately.

What Is Cron & Crontab?
Cron Syntax Explained
Managing the Cron Service
User Crontabs & Scheduling Jobs
Cron Expressions with Examples
Special Cron Keywords
Running Multiple Jobs
Real-World Business Use Case
Conclusion

What Is Cron & Crontab?

cron is a built-in Linux scheduler used to run commands or scripts at specific intervals. The configuration file that defines scheduled tasks is known as the crontab.

Cron is ideal for:

Automated system maintenance
Backups and cleanup tasks
Log rotation and reporting
Scheduled data transfers
Compliance jobs and monitoring

Cron automates repetitive tasks without human intervention, improving consistency and reliability.

Cron Syntax Explained

Every cron entry consists of five time fields followed by the command:

MIN   HOUR   DOM   MON   DOW   CMD

⚠️ Important: In the editor, fields must be separated using a TAB, not a spacebar.

Field meanings

Field	Description	Range
MIN	Minute	0–59
HOUR	Hour	0–23
DOM	Day of month	1–31
MON	Month	1–12
DOW	Day of week	0–6 (Sun=0, Mon=1 … Sat=6)
CMD	Command to execute	—

Managing the Cron Service

Check if cron service is running:

systemctl status crond

Enable cron service at boot:

systemctl enable crond

Restart cron service:

systemctl restart crond

User Crontabs & Scheduling Jobs

Every user can have their own crontab.

Edit crontab as a specific user

crontab -e -u username

Example: Schedule a job for user `natasha` to print a message on 15 June at 14:23

su natasha
crontab -e

Inside the editor:

23  14  15  06  *   /usr/bin/echo hello

Save with ESC, then :wq.

Verify:

crontab -l -u natasha

Cron Expressions with Examples

🔹 Run a job every minute

*   *   *   *   *   /usr/bin/echo "Running every minute"

🔹 Run a job every 5 minutes

*/5 *   *   *   *   /usr/bin/date >> /tmp/every5min.log

🔹 Run a job every 2 minutes in the first 10 minutes

0-10/2  *   *   *   *   /usr/bin/echo "Running every 2 mins for first 10 mins"

🔹 Run a job twice a day at 1:00 and 11:00

0   1,11    *   *   *   /usr/bin/echo "Twice a day task"

🔹 Run a job weekdays only, between 9am–6pm

0   9-18    *   *   1-5 /usr/bin/echo "Weekday work hours task"

Special Cron Keywords

Some schedules do not need 5 fields. Cron provides helpful shortcuts:

Keyword	Equivalent Schedule
`@yearly` / `@annually`	`0 0 1 1 *`
`@monthly`	`0 0 1 * *`
`@daily` / `@midnight`	`0 0 * * *`
`@hourly`	`0 * * * *`
`@weekly`	`0 0 * * 0`
`@reboot`	Run once after system boots

Example: Run a script that sends a New Year system status report on January 1st at 00:00 each year:

@yearly /usr/bin/echo "Happy New Year! System status report triggered." >> /var/log/newyear.log

Running Multiple Jobs

You can schedule multiple lines in the same user's crontab:

# Run a job every day at 14:23
23  14  *   *   *   /usr/bin/echo hello

# Run a job every 5 minutes
*/5 *   *   *   *   /usr/bin/date >> /home/natasha/data.log

# Run a job every Sunday at midnight
0   0   *   *   0   /usr/bin/echo hiyaa

Real-World Business Use Case

Scenario: Automated Reporting & Compliance in a Retail Enterprise

A retail organization needs daily sales, inventory snapshots, and error logs automatically sent to the analytics team.

Using crontab:

A nightly inventory export runs at 23:59.
A compliance log archival runs every 6 hours.
A backup script runs every day at 02:00.

Examples:

59  23  *   *   *   /usr/local/bin/export_inventory.sh
0   */6 *   *   *   /usr/local/bin/archive_logs.sh
0   2   *   *   *   /usr/local/bin/db_backup.sh

Business impact:

Reduces manual work for IT and operations teams
Ensures compliance reports are always generated on time
Prevents data loss through automated backups
Improves accuracy by eliminating human errors

Cron jobs become part of the company’s automation backbone, supporting DevOps workflows, auditing, and operational reliability.

Conclusion

Crontab is one of the most powerful automation tools in Linux. With a solid understanding of cron syntax, service management, scheduling patterns, and real-world use cases, you can automate nearly any repetitive task on a Linux system.

Practice these examples, build your own automation routines, and incorporate cron into your RHCSA exam preparation and DevOps projects.

Connect with me on LinkedIn for further discussions and networking opportunities.

Linux in Action: Resetting the root Password on RHEL (RHEL 9 & 10)

DhavalThakar97 — Thu, 04 Dec 2025 19:31:23 +0000

Introduction

Losing administrative access happens: a sudoers misconfiguration, a rotated vault secret that wasn’t propagated, or an offboarding gone wrong. On RHEL 9/10 systems, you can recover by booting into a minimal environment, remounting the system read‑write, and resetting the root password safely.

⚠️ Only perform these steps on systems you are authorized to administer. For production servers, use an approved change window and capture evidence for audit.

This article follows your mapping:

Method A → RHEL 9 using rd.break (dracut emergency shell)
Method B → RHEL 10 using init=/bin/bash (single‑user shell)

It also includes cloud/secure‑boot notes, a security checklist, troubleshooting, and a real‑world business scenario.

Prerequisites
Method A: rd.break (RHEL 9)
Method B: init=/bin/bash (RHEL 10)
Cloud/Virtual Machines & Locked GRUB
Post‑Reset Tasks (Security & SELinux)
Troubleshooting
Conclusion

Prerequisites

Console access (local KVM/iLO/DRAC, VM console, or cloud serial console).
If full‑disk encryption is enabled, you still need the LUKS passphrase at boot.
Systems with a GRUB password or Secure Boot policies may require an approved break‑glass procedure.
SELinux is typically enforcing on RHEL—plan an autorelabel step or the login may fail after reset.

Method A: `rd.break`(RHEL 9)

This method uses the dracut emergency target and a chroot into the installed system.

Reboot the server. When the GRUB menu appears, select the default kernel entry and press e to edit.
On the line beginning with linux (or linuxefi), append a space and:

   rd.break

Press Ctrl+X (or F10) to boot.
You will land at a dracut shell with the root filesystem mounted under /sysroot read‑only. Remount it read‑write:

   mount -o remount rw /sysroot

Chroot into the installed system:

   chroot /sysroot

Reset the root password:

   passwd

Enter and confirm the new password.

Trigger SELinux relabel so contexts match the new shadow entries:

   touch /.autorelabel

Exit the chroot and the emergency shell:

   exit
   exit

The system will continue boot or reboot. The relabel may take several minutes.

Method B: `init=/bin/bash`(RHEL 10)

This method boots directly into a single‑user shell without systemd.

Reboot, press e on the GRUB entry, and on the linux line append:

   init=/bin/bash

Press Ctrl+X (or F10) to boot into a bash shell.
Remount the root filesystem read‑write:

   mount -o remount rw /

Reset the root password:

   passwd

SELinux relabel on next boot:

   touch /.autorelabel

Continue the normal boot sequence:

   exec /sbin/init

Cloud/Virtual Machines & Locked GRUB

GRUB password or UEFI Secure Boot: you may be prompted before you can edit the boot line. Engage your break‑glass procedure or use an attached rescue ISO.
Cloud providers (AWS, Azure, GCP): use the serial/console feature. If GRUB editing is blocked, detach the disk and attach it to a rescue VM to edit /etc/shadow or set the password via chroot.

Post‑Reset Tasks (Security & SELinux)

After you confirm the new password works:

Re‑enable policy: If your environment normally disables direct root login, lock the account again and rely on sudo:

  passwd -l root

Audit: Record the change ticket, timestamp, and the reason. Update your runbook.
Rotate credentials in your password vault and notify on‑call/SOC if required.
Check SELinux status and relabel result:

  sestatus
  ausearch -m USER_LOGIN -ts recent || true

Troubleshooting

Permission denied / read‑only: You likely forgot the remount step. Use mount -o remount rw / or for Method A mount -o remount rw /sysroot then chroot /sysroot.
Login still fails: Ensure you ran touch /.autorelabel (inside the chroot for Method A) and allowed the relabel to complete.
Encrypted volumes: You must still supply the LUKS passphrase at boot.
GRUB changes ignored: Verify you edited the correct linux line and booted with Ctrl+X/F10.

Conclusion

You now have two procedures mapped to your environment to reset the root password on RHEL 9 and RHEL 10, plus guardrails for cloud and secure‑booted hosts. Practice both flows in a lab so you’re ready when a break‑glass event hits.

Connect with me on LinkedIn for further discussions and networking opportunities.

Linux in Action: Mastering ACLs (Access Control Lists) for RHCSA

DhavalThakar97 — Thu, 22 May 2025 20:16:46 +0000

Introduction

Basic Unix permissions (rwx) work well for many scenarios—but they can fall short when we need fine‑grained access control. Access Control Lists (ACLs) extend the traditional model, allowing you to grant specific permissions to additional users or groups without altering the file’s primary ownership.

ACL management is a core skill assessed in the Red Hat Certified System Administrator (RHCSA) exam and is vital for real‑world multi‑tenant environments.

📌 This guide focuses on the exact depth of ACL knowledge required for RHCSA, with practical demonstrations you can reproduce in a lab.

What Are ACLs and Why Use Them?
Viewing Current ACLs with getfacl
Granting Permissions with setfacl -m
Default ACLs for Directories
Removing ACL Entries
Best Practices and Exam Tips
Real-World Use Case
Conclusion

What Are ACLs and Why Use Them? and Why Use Them?

Traditional permissions map a single owner, group, and others to rwx bits. ACLs let you assign additional rules such as “give user bob read access to /shared/logs/” without changing group ownership.

Key benefits:

Fine‑tuned collaboration between teams
Avoids creating numerous ad‑hoc groups
Granular permissions for backup, audit, or DevOps service accounts

RHCSA Scope: You must know how to view, add, modify, and delete ACLs and set default ACLs on directories.

Viewing Current ACLs with `getfacl`

# getfacl /srv/projects/

Sample output:

# file: srv/projects/
# owner: root
# group: devops
drwxrwx---+
user::rwx
group::rwx
other::---
user:alice:r-x

+ after directory permissions indicates extended ACLs exist.
Extra line user:alice:r-x shows ACL entry for user alice.

Granting Permissions with `setfacl -m`

Give a user access

# setfacl -m u:alice:rwx /srv/projects/

-m modifies or adds an entry. Always use rwx letters (RHCSA recommendation) rather than octal.

Give a group access

# setfacl -m g:qa:r-x /srv/projects/

Verify:

# getfacl /srv/projects/

Default ACLs for Directories

A default ACL applies automatically to new files/directories created inside the parent directory.

# setfacl -d -m u:alice:rwx /srv/projects/

-d targets default ACL.
Combine with regular ACLs for full control.

🔎 RHCSA Tip: The exam often asks you to ensure future files inherit a permission—this is where default ACLs shine.

Removing ACL Entries

Remove a single ACL rule

# setfacl -x u:alice /srv/projects/

Strip all ACLs (restore basic permissions)

# setfacl -b /srv/projects/

Re‑check with getfacl to confirm cleanup.

Best Practices and Exam Tips

Task	Command	Remember
View ACL	`getfacl path`	Look for `+` on `ls -l` output
Add user ACL	`setfacl -m u:name:perm path`	Use `rwx` letters
Add group ACL	`setfacl -m g:name:perm path`	Same syntax
Default ACL	`setfacl -d -m u:name:perm dir`	Only on directories
Remove single ACL	`setfacl -x u:name path`	Also works with `g:`
Remove all ACL	`setfacl -b path`	Restores basic `rwx` model

Exam strategy

Always run getfacl before and after changes to verify.
Use rwx syntax over numeric.
Remember default ACLs affect newly created items, not existing ones.

Real-World Use Case

Scenario: Secure Collaboration in a FinTech DevOps Pipeline

A FinTech company hosts its application code under /srv/app-repos/. Development and operations teams need different levels of access:

Role	Required Access	ACL Action
CI/CD Runner (user `jenkins`)	`rwx` on build directory only	`setfacl -m u:jenkins:rwx /srv/app-repos/build`
Developers (group `devs`)	read/execute on repos, no write	`setfacl -m g:devs:rx /srv/app-repos/`
SRE Team (group `sre`)	full access for troubleshooting	`setfacl -m g:sre:rwx /srv/app-repos/`

Default ACL ensures any future sub‑directories inherit these rules:

setfacl -d -m g:devs:rx /srv/app-repos/
setfacl -d -m g:sre:rwx /srv/app-repos/

Business impact:

Developers cannot accidentally modify production artifacts.
CI/CD automation writes builds securely without broadening group ownership.
SREs maintain rapid incident response capability.
Meets PCI-DSS separation‑of‑duties requirements without complex group sprawl.

Conclusion

ACLs provide the missing granularity when basic permissions aren’t enough. For RHCSA success—and real‑world DevOps security—you must be comfortable viewing, setting, and removing ACLs on both files and directories.

🔜 Next Article Preview: We’ll dive into Special Permissions—SetUID, SetGID, and the Sticky Bit—to complete the permissions trilogy for your RHCSA prep.

Connect with me on LinkedIn for further discussions and networking opportunities.

Linux in Action: Understanding Basic File and Directory Permissions

DhavalThakar97 — Thu, 22 May 2025 15:21:39 +0000

Introduction

In the world of Linux, permissions serve as a foundational security layer. They determine who can read, write, or execute a directory or file, providing crucial access control in multi-user environments.

In this article, we’ll focus on Basic Permissions — the first of three key types (Basic, ACLs, and Special Permissions). We'll explore how Linux handles ownership, how to view and modify permissions, and real-world tips for using chmod, chown, and chgrp securely.

📌 Advanced topics like Access Control Lists (ACLs) and Special Permissions (SetUID, SetGID, Sticky Bit) will be covered in separate articles.

What Are Directory Permissions?
Understanding the Permission String
Viewing Permissions
Ownership in Linux
Modifying Permissions with chmod
Numeric (Octal) Permissions
Bonus: The Link Count
Real-World Use Case: DevOps and RHCSA Practice
Conclusion

What Are Directory Permissions?

Permissions in Linux define how users can interact with directories. They are set by the superuser or the owner and are essential for securing shared systems.

There are three permission classes:

User (u): The directory owner
Group (g): Users in the group assigned to the directory
Others (o): Everyone else

And three permission types:

Read (r): List directory contents
Write (w): Create, delete, or rename files in the directory
Execute (x): Access the directory and traverse into it

Understanding the Permission String

When you list directories with ls -ld, the output looks like this:

drwxr-xr-- 3 alice devs 4096 May 25 08:00 /opt/project/

Breakdown:

d indicates it's a directory
rwx – user (owner) permissions
r-x – group permissions
r-- – others' permissions

Viewing Permissions

Directory permissions:

ls -ld /opt/project/

This allows you to audit directory permissions accurately.

Ownership in Linux

Change Directory Owner:

chown john /opt/project/

Change Group Ownership:

chgrp developers /opt/project/

Change Both Owner and Group:

chown john:developers /opt/project/

Verify with:

ls -ld /opt/project/

Modifying Permissions with chmod

Remove all permissions from others:

chmod o-rwx /opt/project/

Remove write permission from group:

chmod g-w /opt/project/

Remove execute from user:

chmod u-x /opt/project/

Add full permissions to user:

chmod u+rwx /opt/project/

Remove all permissions:

chmod u-rwx,g-rwx,o-rwx /opt/project/

Add all permissions:

chmod ugo+rwx /opt/project/

Set exact permissions:

chmod ugo=r-x /opt/project/

Numeric (Octal) Permissions

Each permission maps to a number:

Read = 4
Write = 2
Execute = 1

You sum these for each class:

chmod 750 /opt/project/

User: 7 (rwx)
Group: 5 (r-x)
Others: 0 (no permissions)

Bonus: The Link Count

When you run ls -ld, the second column is the link count:

drwxr-xr-x 2 john devs 4096 May 25 09:00 /opt/project/

Here, the 2 means this directory has two links: one for itself, and one for . or .. in a subdirectory. This number increases with additional subdirectories, including hidden ones.

📌 For files, the link count remains 1 unless hard links are created.

Real-World Use Case: DevOps and RHCSA Practice

In enterprise DevOps pipelines, directory permissions are often managed as part of automation workflows:

CI/CD pipelines: Temporary directories created for builds must be secured using chmod 700 to restrict access to build agents only.
Infrastructure-as-Code (IaC): Tools like Ansible use file modules to set owner, group, and mode for deployment directories.
Multi-tenant servers: RHCSA best practices recommend separating each application’s working directory and locking them down to only authorized groups.
Security audits: Enterprises rely on regular scans of /opt, /var/log, /srv, and /home directories to detect misconfigured permissions that can expose sensitive data.

These practices ensure:

Minimal attack surface
Reduced risk of privilege escalation
Compliance with internal ITGC and external regulations (PCI-DSS, ISO27001)

Conclusion

Basic directory permissions are an essential part of system hardening and operational efficiency. With a solid grasp of chmod, chown, and permission strings, you can confidently secure your Linux environment.

🔐 Next up: We’ll explore Access Control Lists (ACLs) and Special Permissions like SetUID, SetGID, and Sticky Bit.

Stay tuned and stay secure. 🛡️

Connect with me on LinkedIn for further discussions and networking opportunities.

Linux in Action: Mastering Group Account Management & Operations

DhavalThakar97 — Thu, 22 May 2025 01:04:15 +0000

Introduction

In Linux, user management doesn't end at the individual level—group management is equally vital for maintaining a secure, efficient, and organized system. Groups allow system administrators to streamline permissions, collaborate within teams, and enforce consistent access policies across users.

This article dives deep into Linux group account management. We'll explore group types, system files involved, essential commands, and real-world operational tips that apply from small teams to enterprise-grade environments.

What Are Groups in Linux?
Group Account Databases
Essential Group Management Commands
Real-World Notes and Operational Considerations
Conclusion

What Are Groups in Linux?

A group is a logical collection of user accounts. Groups make permission management easier by allowing shared access to files, directories, and system resources among multiple users.

Primary Group

Automatically created when a new user is added.

Each user is assigned a default primary group.

When the user is deleted, the primary group is removed as well.

Secondary Group

Created manually by a superuser.

Users can be added or removed flexibly.

A user may belong to multiple secondary groups simultaneously.

Grouping users is essential for organizing permissions in collaborative environments, such as dev teams, support staff, or project-based access roles.

Group Account Databases

Two critical system files manage group-related data:

`/etc/group`

Defines group names, GIDs (Group IDs), and members.
Readable by all users but modifiable only by root.

`/etc/gshadow`

Stores secure group administration data (group passwords, admins).
Accessible only by privileged users.

Use grep to inspect specific group properties:

grep devteam /etc/group
grep devteam /etc/gshadow

Essential Group Management Commands

Create Group:

groupadd devteam

Creates a new secondary group named devteam.

Check Group Details:

grep devteam /etc/group

Verifies creation, members, and GID.

Modify Group ID:

groupmod -g 1101 devteam

Changes the GID of an existing group.

Add Single Member to Group:

gpasswd -a alice devteam

Adds user alice to devteam.

Remove Single Member from Group:

gpasswd -d alice devteam

Removes user alice from devteam.

Add/Remove Multiple Members:

gpasswd -M bob,charlie,dan devteam

🛑 Caution: This overwrites all existing group members. Always include both new and existing members. Also removes the admin, though they retain implicit privileges.

Assign Group Admin:

gpasswd -A david devteam

Sets david as the group admin.

Remove Group Admin:

gpasswd -A "" devteam

Removes all admin users from the group.

Check Group Admin Info:

grep devteam /etc/gshadow

Displays admin and password info.

Delete Group:

groupdel devteam

Removes the group from the system.

Real-World Notes and Operational Considerations

✅ Automate group operations using tools like Ansible or shell scripts.

✅ Be cautious with gpasswd -M as it replaces all members.

✅ Maintain consistent naming conventions like team_devops, access_hr.

✅ Log all group operations in enterprise setups for audit and compliance.

Conclusion

Mastering group management is essential for scalable Linux administration. From simplifying permissions to maintaining audit compliance, groups provide a powerful mechanism for managing user access efficiently and securely.

Stay consistent, automate where possible, and always verify changes.

Connect with me on LinkedIn for further discussions and networking opportunities.

Linux in Action: Mastering User Account Operations & Management

DhavalThakar97 — Fri, 16 May 2025 19:09:55 +0000

Introduction

Managing users in Linux extends far beyond creating or deleting accounts. It involves orchestrating access, protecting sensitive data, ensuring compliance, and optimizing overall system efficiency. Whether managing large-scale enterprise infrastructure, orchestrating users for containerized microservices, or automating compliance tasks in regulated industries, Linux provides powerful and flexible tools tailored to these complex demands.

This article dives deeply into Linux user management, highlighting essential commands, critical system files, industry best practices, automation strategies, and effective integration with modern Identity and Access Management (IAM) solutions.

Understanding User Types in Linux
UID Allocation and Privileges
Essential System Files
[Quick User Information Lookup
Essential User Management Commands
Advanced User Management Techniques
Real-World Use Case: Enterprise Banking Environment
Pro Tips for Linux System Administrators
Conclusion

Understanding User Types in Linux

Linux distinguishes clearly between user types, streamlining permissions and security management:

System Users

Automatically generated during OS or software installations.

Typically assigned UIDs below 1000.

Lack interactive login capabilities.

Examples: apache, mysql, systemd-network.

Normal Users

Explicitly created by system administrators or automation systems.

Support interactive logins with configurable permissions.

Typically assigned UIDs starting at 1000.

Clear categorization simplifies permission assignments and audits.

UID Allocation and Privileges

Root (UID 0): Full administrative privileges.
System Accounts (UID 1–999): Service-specific limited privileges.
User Accounts (UID 1000+): Customizable interactive accounts.

Use the command id <username> to verify UID assignments, preventing conflicts, particularly when managing centralized authentication systems (LDAP, Active Directory via SSSD).

Essential System Files

`/etc/passwd`

Stores basic user details (username, UID, GID, home directory, shell).
Globally readable; modifications restricted to root.

`/etc/shadow`

Secures encrypted passwords and password policies.
Strictly accessible only to root.

Best Practice: Always back up these files before batch edits or integrations.

Quick User Information Lookup

Rapidly retrieve user details with grep:

grep jane_admin /etc/passwd
grep jane_admin /etc/shadow

Efficient method for user audits in large-scale environments.

Essential User Management Commands

Add User:

useradd tom_user

Typically executed during onboarding.

Set Password:

passwd tom_user

Use this for password management.

Switch User:

su tom_user

Ideal for administrative tasks and troubleshooting.

Delete User, Retain Data:

userdel kate_user

Used when data retention is required.

Delete User, Remove Data:

userdel -r kate_user

Preferred for completely removing terminated or offboarded users.

Verify user deletion:

getent passwd kate_user

Advanced User Modification Techniques

Rename User:

usermod -l emily_new emily_old

Modify UID:

usermod -u 2005 david_admin

Update user Metadata:

usermod -c "QA Lead" lucy_qa

Move user Home Directory:

usermod -d /srv/users/mark_ops -m mark_ops

Manage User Shell:

Disable user login:

usermod -s /sbin/nologin tim_support

Enable interactive shell:

usermod -s /bin/bash sara_dev

Lock/Unlock Accounts:

Temporarily lock an account:

usermod -L guest_account

Unlock a locked account:

usermod -U guest_account

Set Account Expiry:

Define expiration date:

usermod -e 2025-12-31 contractor_jake

Remove expiration date:

usermod -e "" permanent_sam

Real-World Case Study: Banking Sector

Imagine managing 3,000 Linux VMs within a heavily regulated banking environment. Leveraging LDAP integration alongside automation tools like Ansible enables:

Efficient user lifecycle management (useradd, usermod, userdel).
Automated control over vendor and contractor access via expiry dates.
Robust auditing through auditd and SSH session recording.
Granular privilege management using groups (docker, k8s, CI/CD).

These practices ensure:

Adherence to least privilege security principles.
Seamless onboarding and offboarding processes.
Compliance readiness for audits (PCI DSS, SOX, GDPR).

Pro Tips for System Admins

✅ Verify user accounts across networks: getent passwd username.

✅ Avoid UID duplication, especially after VM/container cloning.

✅ Utilize the comment field for essential metadata (role, team).

✅ Regularly check password statuses: passwd -S username.

✅ Audit user logins frequently using: lastlog, faillog, last.

✅ Automate ephemeral user management in CI/CD workflows.

✅ Always version-control and peer-review IAM scripts.

Conclusion

Effective Linux user management combines tactical command execution, robust automation strategies, and rigorous compliance practices. Mastering these aspects empowers administrators to maintain secure, efficient, and scalable systems.

For more Linux insights and best practices, explore additional resources and stay connected within the Linux community.

Connect with me on LinkedIn for further discussions and networking opportunities.

VIM in Action: Mastering the Most Powerful Text Editor for Linux and DevOps

DhavalThakar97 — Thu, 15 May 2025 20:15:32 +0000

Introduction

VIM, known for its speed, flexibility, and terminal efficiency, is foundational in modern Linux-based development and operations. Mastering VIM commands improves your productivity, enhances your troubleshooting capabilities, and allows seamless editing across remote and embedded systems.

In this article, we’ll explore what VIM is, break down its core modes, provide essential keyboard shortcuts, share best practices, and walk through real-world examples. Whether you're just starting or brushing up for RHCSA or DevOps work, this guide is structured to make learning fun and practical.

What is VIM?
VIM Modes – The Heart of Navigation
Best Practice: Enable Line Numbers
Essential VIM Shortcuts (Command Mode)
Fun Learning Challenge: VIM Practice Lab
VIM Tips & Hidden Gems
Conclusion

What is VIM?

VIM stands for Vi IMproved. It is a highly configurable text editor built to enable efficient text editing and scripting from the command line. Originally developed as an enhancement to the vi editor, VIM has become one of the most widely used tools for editing files within terminal-based environments across Unix, Linux, and even Windows (via WSL or Git Bash).

Key Features

Syntax highlighting for many programming languages
Persistent undo history
Support for plugins and themes
Extremely lightweight and fast
Operates completely within the terminal (no GUI required)

VIM is essential in environments where GUI tools are inaccessible — such as remote servers, containers, embedded devices, and CI/CD pipelines.

VIM Modes – The Heart of Navigation

There are three primary modes in VIM. Each one serves a unique purpose:

1. Command Mode

This is the default mode when you open a file.

vim filename.txt

You can navigate, delete, copy, and paste in this mode.
Press i to switch to Insert Mode.

2. Insert Mode

This mode allows you to type, edit, and make changes.
Once you’re done, press ESC to return to Command Mode.

3. Extended Mode

Accessed by pressing : from Command Mode.
You can now issue commands such as:

:wq → Save and quit

:q! → Quit without saving

🎯 Fun Tip: Think of Command Mode as "looking at the paper," Insert Mode as "writing on it," and Extended Mode as "deciding what to do with it."

Best Practice: Enable Line Numbers

Line numbers help you track changes, navigate efficiently, and debug configurations.

Always enable them when working with long scripts or configuration files.

Enable line numbers:

:se nu

Disable line numbers:

:se nonu

✨ Essential VIM Shortcuts (Command Mode)

🔄 Copy Commands

yy – Copy current line
nyy – Copy next n lines
yw – Copy current word

❌ Delete Commands

dd – Delete current line
ndd – Delete next n lines
dw – Delete current word

🚀 Navigation Commands

gg – Go to the top of the file
G – Go to the bottom of the file
ngg or nG – Go to line number n

📌 Other Shortcuts

p – Paste
u – Undo
Ctrl + r – Redo

🧪 Fun Learning Challenge: VIM Practice Lab

Try creating a file and walk through this challenge:

vim demo.txt

Enable line numbers
Insert 5 lines of text
Copy the second line
Paste it below
Delete the last two lines
Save and quit

✅ Repeat this daily for 5 minutes to build muscle memory and become fluent in VIM navigation!

VIM Tips & Hidden Gems

1. Qucikly switch Between Files

Open multiple files:

vim filename1.txt filename2.txt

Switch between files:

:n  #next file
:prev  #previous file

2. Search in VIM

Use / or ? to search forward or backward.

/wordtosearch

Use n and N to jump to the next or previous match.

3. Replace Words

Replace all occurrences of a word in the file using substitution commands.

:%s/apple/android/g

4. Highlight Word

Press * on a word to highlight all its matches in the file.

5. Split Screen Editing

Use :split or :vsplit to open files side-by-side.

Horizontal split:

:split otherfile.txt

Vertical split:

:vsplit otherfile.txt

Use Ctrl + w and arrow keys (or hjkl) to move between splits.

6. Save As

Use the :w command followed by a new filename to save the file under a different name.

:w newfilename.txt

7. Jump to Matching Brackets

Place the cursor on a bracket or brace and press %.

8. Access Built-in Help

Use :help followed by any command name for instant documentation.

:help
:help <command>

Conclusion

VIM may seem overwhelming at first, but with regular use, it becomes a powerful ally in your terminal toolkit. Whether you're editing scripts, updating configuration files, or writing documentation—VIM's efficiency and depth can truly set you apart.

Let’s make VIM second nature — one keystroke at a time. 🚀

📣 Follow me on LinkedIn for more real-world Linux and DevOps guides!

Linux in Action: Managing Directories and Files

DhavalThakar97 — Tue, 13 May 2025 21:16:05 +0000

Introduction

This article focuses on the heart of Linux file system interaction: managing directories and files. These skills are not just essential for RHCSA exam preparation but also critical in real-world environments like DevOps, system automation, and enterprise IT operations.

This guide emphasizes learning-by-doing. Each command is paired with a real-world scenario to help readers understand how it's applied in business and technical contexts.

Overview
Directory Navigation and Management
File Creation and Handling
RHCSA Tips and Additions
Real-world Business Use Case
Conclusion

Overview

Being proficient in file and directory commands helps Linux users automate tasks, organize systems, and manage resources efficiently. Let’s explore these practical commands step by step.

Directory Navigation and Management

ls: The ls command lists the contents of a directory. It helps users view files and folders, check hidden items, and understand file types and permissions when combined with options like -l and -a.

Scenario: A cloud engineer needs to inspect the contents of the root directory to ensure all essential system folders are present after a fresh server deployment.

cd: The cd (change directory) command is used to move between directories in the Linux file system. It's fundamental for navigating the directory structure and organizing file access.

Navigate to a specific folder:

Move one level up:
Return to the home directory:

Scenario: A web administrator navigates to the /etc/nginx directory to verify configuration files and returns to their home directory after editing.

🔧 Try This: Navigate to /etc, move one directory up, then return to your home directory.

mkdir: The mkdir command is used to create one or more directories at once. It's essential for structuring file systems and organizing project environments or logs. The -p flag allows creation of parent directories that do not exist.

Create a single directory:
Create multiple directories:
Create a sequence of directories:
Create nested directories (parent and sub-directories):

Scenario: A finance team sets up folders to store invoice records by creating /data/clients/invoices using the -p option for nested structure.

🔧 Try This: Create nested folders for client records using mkdir -p /data/clients/2025/invoices.

File Creation and Handling

touch: The touch command creates empty files or updates the access and modification timestamps of existing ones. It's widely used in scripting and file preparation steps.

Scenario: A developer initializes an empty README.md file at the root of a new project directory to later add documentation.

🔧 Try This: Create empty files for a new project: touch index.html style.css script.js.

cat: The cat (concatenate) command displays the contents of files, allows you to create new files, and can combine multiple files into one. It is ideal for quickly viewing logs or creating files via terminal input.

Create and write to a file:
Append to a file:
View content of a file:
Merge files into a new one:

Scenario: A documentation team combines the contents of separate markdown files into a complete user manual using cat.

🔧 Try This: Combine two text files using cat file1.txt file2.txt > combined.txt and view the result.

echo: The echo command prints text to the screen or writes it to a file. It's commonly used in scripts to generate output, write configurations, or append logs.

Scenario: A deployment script generates log messages that are appended to a deployment log file using echo.

🔧 Try This: Write a welcome message to a file using echo "Welcome to Linux" > welcome.txt.

cp: The cp (copy) command duplicates files or directories. It's essential for backups, code replication, and preserving original content during changes. Use it with caution when overwriting files.

Copy a file:
Copy a directory and its contents:

Options:
-r: Recursive – copy entire directories and subdirectories
-v: Verbose – show each file as it's copied
-f: Force – overwrite destination files without prompting

Scenario: A web server admin copies the entire website directory before updating it to ensure they can roll back if needed.

🔧 Try This: Copy your backup folder to /tmp using cp -rvf backup /tmp/backup_copy.

mv: The mv (move) command relocates files or directories and is also used to rename them. It is vital for organizing data or updating file names during processing or archiving.

Rename a file:
Move a file to another directory:

Options:
-v: Verbose – show actions as they happen
-f: Force – overwrite existing files at destination without prompting

Scenario: A marketing analyst renames a draft report and moves it to the shared team directory once finalized.

🔧 Try This: Rename a test file from test.txt to test_renamed.txt and move it to your Documents folder.

rm: The rm (remove) command deletes files and directories. It is powerful and permanent especially with -rf so it should be used carefully to avoid unintentional data loss.

Delete a single file:
Delete a directory and all its contents:

Options:
-r: Recursive – delete directories and their contents
-f: Force – ignore nonexistent files and suppress prompts
-v: Verbose – show files as they are deleted

Scenario: An IT support team clears out outdated system logs to free up space and keep logs organized.

🔧 Try This: Remove an old temp directory using rm -rvf /tmp/old_project.

RHCSA Tips and Additions

🧠 Pro Tip: Use mkdir {dev,test,prod} to instantly create environments for staging deployments.

🧠 Pro Tip: Always run rm with caution. Start with rm -v before adding -rf to avoid mistakes.

Install:
Visualize structure:
Detailed file into:

Real-world Business Use Case

Scenario: Automating Log and File Management for a SaaS Monitoring Team

In a cloud-based SaaS environment, the platform team maintains logs for services like authentication, billing, and monitoring. To handle logs efficiently, a manual script is used at the start and end of each day with the following flow:

mkdir -p: Creates service-specific folders like /logs/authentication/2025-05-12.
touch: Generates empty error.log and access.log files for each service.
echo or cat >>: Appends service status and error messages during runtime.
mv: Moves daily logs to /logs/archive/YYYY/MM/DD for historical tracking.
rm -rvf: Deletes logs older than 15 days to maintain disk space.
ls -l and chmod: Verifies and adjusts file access to ensure only authorized teams can read or write logs.

✅ This routine helps the business:

Stay compliant with audit standards
Keep logging organized by service and time
Save storage and avoid clutter
Secure sensitive log data from unauthorized access

📌 Summary Cheatsheet

Command	Description	Common Options	Example Usage
`ls`	List directory contents	`-l` (long), `-a` (all)	`ls -la /etc`
`cd`	Change current directory	`..` (up), `~` (home)	`cd /var/log`
`mkdir`	Create new directories	`-p` (parents)	`mkdir -p /data/logs/2025`
`touch`	Create empty files / update timestamp	–	`touch file.txt`
`cat`	View, create, or merge file contents	`>`, `>>`, `<`	`cat file1.txt file2.txt > combined.txt`
`echo`	Print or write a line to a file	`>`, `>>`	`echo \"Hello\" > hello.txt`
`cp`	Copy files or directories	`-r`, `-v`, `-f`	`cp -rvf /app /backup/app`
`mv`	Move or rename files	`-v`, `-f`	`mv oldname.txt newname.txt`
`rm`	Delete files or directories	`-r`, `-f`, `-v`	`rm -rvf /tmp/testdir`

Conclusion

Each Linux command has a real, impactful use in business and tech. By understanding these commands in real-world contexts, readers can build confidence, solve problems faster, and work toward certifications like RHCSA.

Have your own scenario to share? Drop it in the comments—we’d love to learn from your journey too!

🔗 Let’s connect and keep learning together: Follow me on Linkedin 🔗

Getting Started with Linux: System Information and User Management

DhavalThakar97 — Mon, 12 May 2025 21:42:33 +0000

Introduction

Linux, known for its reliability, flexibility, and security, is foundational in modern IT environments. Mastering Linux commands boosts productivity, enhances troubleshooting capabilities, and supports critical business operations. In this first article of a two-part series, we explore essential Linux commands related to system information and user management. Real-world business examples and clear explanations will help solidify your understanding.

Overview
System Information Commands
User Management Commands
Suggested Screenshot Locations
Additional RHCSA Commands
Real-world Business Use Case
Conclusion

Overview

Mastering basic Linux commands empowers IT professionals to efficiently manage systems, optimize workflows, and prepare effectively for professional certifications like Red Hat Certified System Administrator (RHCSA).

System information Commands

uname: The uname command reveals the name of your Linux operating system, helping quickly identify the OS in use.
uname -r: Use this command to find your Linux kernel version, essential for troubleshooting compatibility and stability issues.
pwd: pwd (print working directory) shows your current directory path, essential for navigation and script automation.

User Management Commands

su: The su (switch user) command is crucial for administrators needing to switch contexts between user accounts, typically requiring superuser privileges.
whoami: Quickly identify the currently logged-in user account.

Additional RHCSA Commands

id: Displays detailed user identity information, including UID, GID, and group memberships.
history: Lists recently executed commands, beneficial for auditing and reproducing previous operations.
hostname: Displays your system’s network identity, crucial in networked environments.
date: Shows or configures the system date and time.

Real-world Business Use Case

Scenario: Secure User Account Management in Financial Institutions

Financial institutions often have strict compliance requirements. Linux administrators use commands like su, whoami, and id to securely manage user accounts, maintain audit trails, and verify user permissions. This ensures sensitive financial data is accessed only by authorized personnel, maintaining integrity and compliance.

Conclusion

Familiarity with these foundational Linux commands greatly enhances your system management abilities, improves operational security, and supports efficient problem-solving. Stay tuned for next article, where we will explore directory navigation, file operations, and permission management in depth.

We encourage you to leave your comments, questions, and tips below. Let's continue the discussion and connect with each other to share experiences and insights about mastering this incredible operating system!

Linux in Action - File Structure Hierarchy and Its Role in Modern Business

DhavalThakar97 — Mon, 14 Apr 2025 21:09:33 +0000

Introduction

Linux is a powerful and versatile operating system that has become the backbone of many businesses and industries. Its open-source nature allows for customization and flexibility, making it an ideal choice for server management and various applications. In this article, we will explore the fundamental aspects of Linux, including its kernel, different distributions, and its file structure hierarchy. We will also explore into why Linux is preferred by tech professionals and how it empowers businesses. This content is designed to be accessible to both tech enthusiasts and those new to the world of Linux.

Overview
Linux Kernel and Distributions
Linux Usage in AWS
Linux and Business Empowerment
Bash and System Administration
DevOps with Linux
Linux File Structure Hierarchy
RHEL 9 and Its Industrial Use Cases
Benefits of Understanding Linux
Final Thoughts

Overview

Linux is known for its stability, security, and efficiency. At its core is a well-defined file hierarchy that lays out every file and directory in a predictable way. This structure is consistent across most Linux distributions, meaning what you learn here will apply to Ubuntu, Fedora, Arch, and more.

Tip: Understanding Linux doesn’t just help with your personal project, it’s also a major plus in professional settings where Linux powers servers and cloud environments.

Linux Kernel and Distributions

The Linux kernel is the core component of the Linux operating system. It is responsible for managing system resources, such as the CPU, memory, and devices. The kernel acts as a bridge between the hardware and software, ensuring efficient communication and operation.

There are various Linux distributions, each tailored to different needs and preferences. Some of the most popular distributions include:

Ubuntu: Known for its user-friendly interface and strong community support, Ubuntu is widely used for desktops and servers.
Debian: A stable and versatile distribution, Debian is favored for its robustness and extensive software repository.
Fedora: Sponsored by Red Hat, Fedora is known for its cutting-edge features and rapid development cycle.
CentOS: A free and open-source alternative to RHEL, CentOS is popular for enterprise environments.
Red Hat Enterprise Linux (RHEL): A leading distribution in industrial settings, RHEL offers stability, security, and comprehensive support.
Arch Linux: Known for its simplicity and customization, Arch Linux is preferred by advanced users who want full control over their system.
SUSE Linux Enterprise: A distribution focused on enterprise solutions, SUSE provides robust support and scalability.

Linux Usage in AWS

Linux plays a crucial role in AWS's backend infrastructure. Many of the services offered by AWS, such as EC2 (Elastic Compute Cloud), Lambda, and ECS (Elastic Container Service), are built on Linux-based systems. Linux's open-source nature allows AWS to customize and optimize the operating system to meet specific needs, providing a robust and secure platform for cloud services.

Linux and Business Empowerment

Linux is a powerful operating system that has become the backbone of many businesses. Its open-source nature allows for customization and flexibility, making it an ideal choice for server management. Tech professionals prefer Linux for its stability, security, and efficiency. It supports a wide range of applications and services, making it a versatile platform for various business needs.

Business Use Case:
Many financial institutions use Linux to run their trading platforms and manage large-scale databases. Its stability and security features ensure that sensitive financial data is protected and transactions are processed efficiently.

Bash and System Administration

Bash, or the Bourne Again Shell, is a command-line interface that enables users to perform system administration tasks efficiently. With Bash, you can automate repetitive tasks, manage files, and configure system settings. It is an essential tool for system administrators, providing powerful scripting capabilities to streamline operations.

Business Use Case:
In the healthcare industry, Bash scripts are used to automate the processing of patient records and manage system backups. This automation helps reduce manual errors and ensures that critical data is securely stored.

DevOps with Linux

Linux plays a crucial role in DevOps practices, facilitating continuous integration and continuous deployment (CI/CD). Its compatibility with various automation tools and frameworks makes it a preferred choice for DevOps engineers. By leveraging Linux, teams can automate workflows, monitor systems, and ensure seamless collaboration between development and operations.

Business Use Case:
E-commerce companies use Linux-based DevOps tools to manage their online platforms. Automation helps in deploying updates, monitoring website performance, and ensuring a smooth user experience for customers.

Linux File Structure Hierarchy

The Linux file structure is organized in a hierarchical manner, starting from the root directory /. Here are the key folders under the top-level directory:

Directory	Purpose
`/`	Root of the file system; the starting point.
`/root`	Home directory for the root (superuser).
`/bin`	Essential binary commands.
`/sbin`	System administration binaries.
`/etc`	Configuration files for services and applications.
`/home`	User home directories.
`/dev`	Device files.
`/var`	Variable data such as logs and cache.
`/proc`	Runtime system process information.
`/usr`	User-level applications and binaries.
`/opt`	Optional third-party applications.
`/mnt`	Temporary mount point for external file systems.
`/media`	Auto-mounted removable media.
`/boot`	Stores boot loader files, including the kernel and other files needed to boot the system.
`/lib`	Shared library files that are used by the binaries in `/bin` and `/sbin`.
`/run`	Contains runtime data for processes and applications. This directory is used for storing temporary data that is needed during system operation.
`/sys`	Contains system information and configuration files. This directory is used for interacting with the kernel and hardware.
`/tmp`	Temporary files. This directory is used for storing files that are needed temporarily and can be deleted after use.

RHEL 9 and Its Industrial Use Cases

Red Hat Enterprise Linux (RHEL) 9 is a leading Linux distribution favored in industrial settings for several reasons:

Stability and Reliability: RHEL 9 offers a stable and reliable platform, ensuring minimal downtime and consistent performance. This is crucial for industries that require uninterrupted operations.
Security: RHEL 9 provides robust security features, including advanced access controls, encryption, and regular security updates. This helps protect sensitive industrial data and systems from threats.
Support and Maintenance: Red Hat offers comprehensive support and maintenance services for RHEL 9, including long-term support and regular updates. This ensures that industrial systems remain up-to-date and secure.
Scalability: RHEL 9 is designed to scale efficiently, making it suitable for large industrial environments with growing demands. It can handle high workloads and complex applications with ease.
Compatibility: RHEL 9 is compatible with a wide range of hardware and software, allowing industries to integrate it seamlessly into their existing infrastructure. This flexibility is essential for diverse industrial applications.

Business Use Case:
Manufacturing companies use RHEL 9 to manage their production systems and ensure efficient operations. Its scalability allows them to handle large volumes of data and integrate various industrial applications seamlessly.

Benefits of Understanding Linux

Efficiency: Spend less time hunting for files and more time getting things done.
Improved Security: Know where critical files live so you can lock them down properly.
Better Collaboration: Everyone on your team speaks the same language regarding file locations and structure.
Simplified Debugging: Quickly locate logs and config files to fix issues faster.

Final Thoughts

Mastering Linux and its file structure hierarchy is a valuable skill that can significantly enhance your productivity and effectiveness in both personal and professional settings. By understanding the organization of files and directories, you can navigate your system with confidence, automate tasks using Bash, and leverage Linux's capabilities in DevOps and server management. This knowledge will empower you to tackle complex challenges and optimize your workflows, making you a more proficient and versatile professional.

DEV Community: DhavalThakar97

Linux in Action: Mastering Crontab for Task Scheduling (RHCSA & DevOps)

Introduction

Table of Contents

What Is Cron & Crontab?

Cron Syntax Explained

Field meanings

Managing the Cron Service

User Crontabs & Scheduling Jobs

Edit crontab as a specific user

Example: Schedule a job for user natasha to print a message on 15 June at 14:23

Cron Expressions with Examples

🔹 Run a job every minute

🔹 Run a job every 5 minutes

🔹 Run a job every 2 minutes in the first 10 minutes

🔹 Run a job twice a day at 1:00 and 11:00

🔹 Run a job weekdays only, between 9am–6pm

Special Cron Keywords

Example: Run a script that sends a New Year system status report on January 1st at 00:00 each year:

Running Multiple Jobs

Real-World Business Use Case

Scenario: Automated Reporting & Compliance in a Retail Enterprise

Conclusion

Linux in Action: Resetting the root Password on RHEL (RHEL 9 & 10)

Introduction

Table of Contents

Prerequisites

Method A: rd.break(RHEL 9)

Method B: init=/bin/bash(RHEL 10)

Cloud/Virtual Machines & Locked GRUB

Post‑Reset Tasks (Security & SELinux)

Troubleshooting

Conclusion

Linux in Action: Mastering ACLs (Access Control Lists) for RHCSA

Introduction

Table of Contents

What Are ACLs and Why Use Them? and Why Use Them?

Viewing Current ACLs with getfacl

Granting Permissions with setfacl -m

Give a user access

Give a group access

Default ACLs for Directories

Removing ACL Entries

Remove a single ACL rule

Strip all ACLs (restore basic permissions)

Best Practices and Exam Tips

Real-World Use Case

Scenario: Secure Collaboration in a FinTech DevOps Pipeline

Conclusion

Linux in Action: Understanding Basic File and Directory Permissions

Introduction

Table of Contents

What Are Directory Permissions?

Understanding the Permission String

Viewing Permissions

Ownership in Linux

Change Directory Owner:

Change Group Ownership:

Change Both Owner and Group:

Modifying Permissions with chmod

Remove all permissions from others:

Remove write permission from group:

Remove execute from user:

Add full permissions to user:

Remove all permissions:

Add all permissions:

Set exact permissions:

Numeric (Octal) Permissions

Bonus: The Link Count

Real-World Use Case: DevOps and RHCSA Practice

Conclusion

Linux in Action: Mastering Group Account Management & Operations

Introduction

Table of Contents

What Are Groups in Linux?

Primary Group

Secondary Group

Group Account Databases

/etc/group

/etc/gshadow

Example: Schedule a job for user `natasha` to print a message on 15 June at 14:23

Method A: `rd.break`(RHEL 9)

Method B: `init=/bin/bash`(RHEL 10)

Viewing Current ACLs with `getfacl`

Granting Permissions with `setfacl -m`

`/etc/group`

`/etc/gshadow`

`/etc/passwd`

`/etc/shadow`