DEV Community: AugustineOzor

Mastering User Management, Authentication, and Process Monitoring in Linux" published

AugustineOzor — Fri, 23 May 2025 16:22:54 +0000

Switch Users and sudo Access
Monitor Logged-In Users
Communicate with Logged-In Users
Linux Account Authentication
Account Types and Directory Services
Useful System Utility Commands
Processes and Jobs
Managing Services and Jobs

Description
Learn how to manage users, monitor sessions, use sudo, and handle Linux processes and services with practical command-line examples.

This guide covers a wide range of foundational topics in Linux system administration, including user switching, sudo access, monitoring user sessions, account authentication, and managing services and processes.

Switch Users and sudo Access

Linux allows you to switch users or run administrative commands without fully logging into another account.

Switch User:

sudo su - username
Temporarily switch to another user’s shell. Useful when performing actions as another user.

Run as Superuser

sudo command
Execute one command with superuser privileges. Safer than logging in as root.

sudo command

visudo
This safely opens the */etc/sudoers * file for editing, which controls sudo permissions. Avoid editing this file directly.

alice ALL=(ALL) NOPASSWD: ALL
This allows the user alice to run any command as sudo without being prompted for a password.

Monitor Logged-In Users

Linux provides tools to view user activity and login history, which is helpful for security and troubleshooting.
who
Shows who is currently logged in and from where.

last
Displays login history using data from /var/log/wtmp.

w
Gives detailed information about current users and their active processes.

id Displays UID, GID, and group memberships of the specified user.
id admin-1

Communicate with Logged-In Users

You can send messages to users on the system using these commands.
users Prints the usernames of users currently logged in.
wall Broadcasts a message to all terminal users.

`wall system will be updated on Monday 25th at 2pm

write Sends a direct message to another user’s terminal. Type your message and press** Ctrl+D **to send.
write admin-1

I logged on to admin-1 user on a different terminal and you can see the message was sent to the user successfully.

Linux Account Authentication

Linux authentication verifies a user’s identity. Accounts can be stored locally or managed centrally through a directory service.

Local accounts: Defined in /etc/passwd, managed on the local machine.
Domain accounts: Managed through centralized systems like LDAP or Active Directory.

Account Types and Directory Services

Different systems are used to manage identities and authentication across networks.

Directory Service	Description
Active Directory	Microsoft’s centralized directory system
IDM	Red Hat’s Identity Manager (based on FreeIPA)
WinBIND	Allows Linux systems to authenticate against AD via Samba
OpenLDAP	Open-source implementation of LDAP
IBM Directory	IBM’s enterprise-grade directory service
JumpCloud	Cloud-based directory platform
LDAP	Lightweight Directory Access Protocol, used for querying and modifying directory services

Useful System Utility Commands

Basic system utilities that help admins quickly gather information about the system

Command	Description
date	Displays current date and time
uptime	Shows how long the system has been running
hostname	Displays or sets the system’s hostname
uname	Displays kernel and system information
which	Finds the location of a command
cal	Displays a calendar
bc	Basic calculator

Processes and Jobs

Processes are instances of running programs. Jobs may refer to background or scheduled tasks.

Applications: GUI or command-line programs
Scripts: Shell or other language scripts
Processes: Running instances of programs
Daemons: Background services (e.g., sshd)
Threads: Lightweight processes running within a parent process
Jobs: Commands or tasks sent to the background or scheduled

Managing Services and Jobs

Manage services and processes using the following tool.
systemctl / service
sudo systemctl status crond Check service status (systemd and SysV init compatible).
sudo service nginx status - will show the same result

ps Shows a snapshot of all running processes. There are several options you can with ps.

top Real-time view of system performance and resource usage.

kill Terminates a process by PID.

kill process ID

crontab -e Schedules recurring tasks (cron jobs).

Breakdown

0 → Minute (0th minute)
17 → Hour (5 PM, in 24-hour format)
* * * - Every day of the month, every month, every day of the week
/home/student/backup.sh - Full path to the script or command to execute

These commands and concepts are essential for effective Linux administration. Whether you're building automation with Ansible, managing user accounts, or monitoring system processes, mastering these tools will greatly increase your confidence and efficiency.

Efficient File Management in Linux

AugustineOzor — Wed, 07 May 2025 20:22:46 +0000

Comparing Files
Compressing and Uncompressing Files
Truncating File Size
Combining and Splitting Files

Description

Managing files effectively is a critical skill for system administrators and DevOps engineers. In this article, we'll cover file comparison, compression, truncation, and filensplitting techniques that will enhance your command line productivity.

Comparing Files

Efficiently comparing files is crucial for version control and troubleshooting. Here are the primary commands:

diff (Line by line comparison)

Compare two text files line by line

diff file1.txt file2.txt

Example

cmp (Byte by byte comparison)

Compare two files byte by byte
cmp file1.txt file2.txt

Example

Compressing and Uncompressing Files

File compression saves space and reduces transfer time.

tar (Tape Archive, often used for creating compressed archives)

Create an archive
man tar - to check the function of tar
Example
tar -cvf archive.tar logfile.txt

Extract the archive
tar -xvf archive.tar
Example
tar -xvf files.tar

gzip (Compress files) gzip logfile.txt gzip -d logfile.txt.gz # Decompressing with gzip gunzip file.txt.gz # Alternative decompression

Truncating File Size

Reduce or extend file sizes to a specific size using the truncate command.

Truncate or extend a file to 10 bytes
truncate -s 10 testfile1

Combining and Splitting Files

Combining Multiple Files

Combine multiple files into one
cat testfile1.txt testfile2.txt > combined.txt

Result

Splitting a File Split a file into smaller chunks: split -l 100 split.txt childfile.txt This command will split split.txt into 100-line chunks, creating files like childfile.txtaa, childfile.txtab so on.

These commands are essential for efficiently managing files on Linux servers. Understanding their capabilities can significantly streamline your workflow as a system administrator or DevOps engineer.

Mastering Linux Text Processing Commands: cut, awk, grep, and more

AugustineOzor — Mon, 05 May 2025 17:25:59 +0000

cut: Extracting Specific Parts of a Line
awk: Field-Based Processing and Pattern Matching
grep & egrep: Pattern Search
sort: Sorting Output
uniq: Finding Unique Lines
wc: Word, Line, and Character Count
Conclusion

Description

Learn how to manipulate, filter, and analyze text in Linux using powerful tools like cut, awk, grep, sort, uniq, and wc — with examples.

`cut`: Extracting Specific Parts of a Line

The cut command allows you to extract parts of a line based on character position, byte size, or delimiter.

Common `cut` Examples:

Command	Description
`cut --version`	Check version
`cut -c1 filename`	Show only the first character of each line
`cut -c1,2,4 filename`	Show characters 1, 2, and 4
`cut -c1-3 filename`	Show a range of characters
`cut -b1-3 filename`	Cut by byte size
`cut -d: -f6 /etc/passwd`	Show the 6th field, using `:` as delimiter
`cut -d: -f6-7 /etc/passwd`	Show fields 6 and 7
`ls -l	cut -c2-4`

cut --version
cut -c1 file6
cut -c1,2,4 file6
cut -c1-3 file6
cut -b1-3 file6
cut -d: -f6 /etc/passwd
cut -d: -f6-7 /etc/passwd
ls -l | cut -c1-4

`awk`: Field-Based Processing and Pattern Matching

awk is a powerful text-processing language great for extracting and analyzing structured data.

Common `awk` Examples:

Command	Description
`awk --version`	Check version
`awk '{print $1}' file`	Show the first field of each line
`ls -l	awk '{print $1,$3}'`
`ls -l	awk '{print $NF}'`
`awk '/Jerry/ {print}' file`	Show lines containing "Jerry"
`awk -F: '{print $1}' /etc/passwd`	Show the first field using `:` as delimiter
`echo "Hello Tom"	awk '{$2="Adam"; print $0}'`
`awk 'length($0) > 15' file`	Show lines longer than 15 characters
`ls -l	awk '{if($9=="seinfeld") print $0;}'`
`ls -l	awk '{print NF}'`

awk --version
awk '{print $1}' file6
ls -l | awk '{print $1,$3}

`grep` & `egrep`: Pattern Search

Use grep to search for patterns in text files.

Command	Description
`grep 'error' logfile.txt`	Search for "error" in a file
`egrep 'warn	fail' logfile.txt`
`grep -i 'login' file`	Case-insensitive search
`grep -v 'debug' file`	Exclude lines with "debug"
`grep -r 'main' /etc/`	Recursively search through directories

grep 'error' logfile.txt
egrep 'warn|fail' logfile.txt
grep -v 'fail' logfile.txt
grep -r 'main' /etc/

`sort`: Sorting Output

Sort lines in alphabetical or numerical order.

Command	Description
`sort file.txt`	Sort file alphabetically
`sort -r file.txt`	Reverse sort
`sort -n numbers.txt`	Sort numerically
`sort -u file.txt`	Remove duplicates after sorting

`uniq`: Finding Unique Lines

Filters repeated lines. Often used with sort.

Command	Description
`uniq file.txt`	Show unique lines (removes duplicates)
`sort file.txt	uniq`
`uniq -c file.txt`	Count occurrences of each line

`wc`: Word, Line, and Character Count

wc stands for word count and can be used for multiple metrics.

Command	Description
`wc -l file.txt`	Count lines
`wc -w file.txt`	Count words
`wc -c file.txt`	Count characters (bytes)
`cat file.txt	wc`

wc logfile.txt
wc -w logfile.txt
wc -c logfile.txt
cat logfile.txt | wc

Conclusion

These commands are the backbone of text processing and data filtering on the Linux command line. Whether you're working with logs, config files, or large datasets, knowing how to combine and use cut, awk, grep, sort, uniq, and wc will make your life a lot easier.

Embracing Open Standards in Cloud-Native Development

AugustineOzor — Thu, 01 May 2025 21:17:50 +0000

Why Open Standards Matter
Key Open Standards in the Cloud-Native Ecosystem
- Open Container Initiative (OCI)
- Container Network Interface (CNI)
- Container Runtime Interface (CRI)
- Container Storage Interface (CSI)
- Service Mesh Interface (SMI)
CNCF Project Maturity Levels
- Sandbox Stage
- Incubating Stage
- Graduation Stage
Conclusion

Description

In the rapidly evolving landscape of cloud-native technologies, open standards play a pivotal role in ensuring interoperability, scalability, and innovation. By adhering to open specifications, developers and organizations can avoid vendor lock-in, foster collaboration, and build robust systems that stand the test of time.

Why Open Standards Matter

Open standards are the backbone of a healthy and collaborative cloud-native ecosystem. They provide a common language and set of expectations that enable diverse tools and platforms to work together seamlessly. By embracing open standards, developers can:

Avoid Vendor Lock-In: Easily switch between providers without significant rework.
Enhance Interoperability: Ensure different components of the system can communicate effectively.
Foster Innovation: Encourage community contributions and rapid development.

Key Open Standards in the Cloud-Native Ecosystem

Open Container Initiative (OCI)

The Open Container Initiative (OCI) defines standards for container formats and runtimes to ensure consistency and compatibility across different container tools and platforms. It encompasses:

Image Specification: Defines how to build and package container images.
Runtime Specification: Specifies the configuration and lifecycle of containers.
Distribution Specification: Standardizes the distribution of container images.

Container Network Interface (CNI)

The Container Network Interface (CNI) provides a standardized way to configure network interfaces in Linux containers. It defines:

A format for network configuration.
A protocol for container runtimes to make network requests.
Procedures for executing and delegating plugins. (A brief overview of the Container Network Interface (CNI ... - Red Hat, cni/SPEC.md at main · containernetworking/cni - GitHub) This ensures that containers can communicate over the network reliably.

Container Runtime Interface (CRI)

The Container Runtime Interface (CRI) is a plugin interface that allows Kubernetes to use various container runtimes without the need to recompile cluster components. It enables: (A standard interface for service meshes on Kubernetes - SMI

Flexibility in choosing container runtimes.
Simplified integration of new runtimes into Kubernetes. This abstraction layer enhances the modularity and extensibility of Kubernetes.

Container Storage Interface (CSI)

The Container Storage Interface (CSI) standardizes the way storage systems are exposed to containerized workloads. It allows:

Third-party storage providers to develop plugins.
Kubernetes and other orchestration systems to integrate storage solutions seamlessly. (Graduated and Incubating Projects | CNCF) This promotes a diverse and flexible storage ecosystem.

Service Mesh Interface (SMI)

The Service Mesh Interface (SMI) provides a standard interface for service meshes on Kubernetes, focusing on:

Traffic policy management.
Telemetry and observability.
Secure service-to-service communication.

By offering a common set of APIs, SMI enables interoperability among different service mesh implementations.

CNCF Project Maturity Levels

The Cloud Native Computing Foundation (CNCF) categorizes projects based on their maturity to guide adoption and development:

Sandbox Stage

This is the entry point for early-stage projects. Sandbox projects are experimental and are meant to foster innovation and community collaboration.

Incubating Stage

Projects in this stage have demonstrated growing adoption and have met certain criteria, including:

Successful use in production by multiple organizations.
A healthy number of contributors and committers.
Clear documentation and versioning.

Graduation Stage

Graduated projects are considered stable and have:

Achieved widespread adoption.
A robust governance and committer process.
Completed a security audit with addressed vulnerabilities. These stages help users assess the readiness and reliability of CNCF projects.

Conclusion

Open standards are essential for building a resilient and interoperable cloud-native ecosystem. By adhering to specifications like OCI, CNI, CRI, CSI, and SMI, developers can create flexible and scalable applications. Understanding the CNCF project maturity levels further aids in making informed decisions about adopting and contributing to these projects.

Embracing open standards not only fosters innovation but also ensures that the cloud-native landscape remains collaborative and vendor-neutral.

Managing Files, Links, and Redirection in Linux

AugustineOzor — Thu, 01 May 2025 14:40:08 +0000

File Links in Linux
- Soft Links (Symbolic)
- Hard Links
Creating Links with ln
Input and Output Redirection
- Standard Output (stdout)
- Appending Output
- Standard Input (stdin)
- Standard Error (stderr)
Conclusion

Description
Learn how to manage files from the command line, create soft and hard links, and use input/output redirection in Linux. Includes clear examples for stdout, stderr, and stdin.

Managing Files, Links, and Redirection in Linux — A Practical Guide

Whether you're preparing for RHCSA, working in DevOps, or just learning Linux, mastering file links and I/O redirection is essential. This guide walks through soft vs hard links and how to use stdin, stdout, and stderr redirection with clear, real-world examples.

File Links in Linux

Every file on a Linux filesystem has an inode, which is like a pointer to where the file lives on the disk.

There are two types of links you can create to refer to a file:

Soft Links (Symbolic)

A soft link points to the original file path.
If the original file is deleted or renamed, the link is broken.
Works across different filesystems. Example ln -s /home/user/original.txt shortcut.txt Ones delete, soft link is broken

Hard Links

A hard link points directly to the file's inode.
Deleting or renaming the original file doesn’t break the link.
Cannot span across different filesystems.
ln /home/user/original.txt clone.txt

Creating Links with `ln`

Command	Description
`ln file1 file2`	Creates a hard link
`ln -s file1 linkname`	Creates a symbolic (soft) link

Input and Output Redirection

Linux uses three default data streams

Stream	Description	File Descriptor
stdin	Standard Input	0
stdout	Standard Output	1
stderr	Standard Error	2

Standard Output (stdout)

By default, command output shows in the terminal. You can redirect it to a file using >
ls -l > listings
pwd > findpath
This overwrites the file if it exists.

Appending Output

Use >> to append to an existing file without overwriting:
ls -la >> listings
echo "Hello World" >> findpath

Standard Input (stdin)

Use < to provide input from a file to a command

cat < listings
mail -s "Office memo" allusers@abc.com < memoletter

Standard Error (stderr)

Redirect errors using 2>
ls -l /root 2> errorfile
telnet localhost 2> errorfile

To redirect both output and errors to the same file
command > output.txt 2>&1

Or, split them
command > out.txt 2> err.txt

Conclusion

Understanding how to manage links and redirect input/output gives you more control over how Linux handles files and processes. Whether you're scripting, debugging, or configuring servers, these tools will save you time and help avoid mistakes.

Serverless Computing: Simplifying Cloud Development

AugustineOzor — Wed, 30 Apr 2025 17:06:23 +0000

Serverless Computing: Simplifying Cloud Development
What Is Serverless Computing?
Function as a Service (FaaS)
Benefits of Serverless Computing
Challenges and Considerations
The Role of CloudEvents
Use Cases for Serverless Computing
Conclusion

Descriptions

Serverless computing is a cloud computing model that allows developers to build and run applications without managing the underlying infrastructure. Despite the name, servers are still involved; however, the responsibility of managing them shifts from the developer to the cloud provider. This model enables developers to focus solely on writing code, while the cloud provider handles server provisioning, scaling, and maintenance.

What Is Serverless Computing?

In traditional cloud computing models, developers must manage server infrastructure, including provisioning, scaling, and maintenance. Serverless computing abstracts these responsibilities, allowing developers to deploy code that automatically scales and executes in response to events. This model is particularly beneficial for applications with variable workloads, as it provides automatic scaling and a pay-per-use billing model.

Function as a Service (FaaS)

Function as a Service (FaaS) is a subset of serverless computing where developers write small, single-purpose functions that are triggered by specific events. These functions are stateless and ephemeral, executing only when invoked and scaling automatically based on demand. FaaS platforms, such as AWS Lambda, Google Cloud Functions, and Azure Functions, manage the execution environment, allowing developers to focus on code rather than infrastructure.

Benefits of Serverless Computing

Reduced Operational Complexity: Developers are relieved from server management tasks, allowing them to concentrate on application logic.

Automatic Scaling: Applications automatically scale up or down based on demand, ensuring optimal resource utilization.

Cost Efficiency: With a pay-per-use billing model, organizations pay only for the compute resources they consume, potentially reducing costs.

Faster Time to Market: Simplified deployment processes enable quicker release cycles and faster innovation.

Challenges and Considerations

Cold Starts: Functions may experience latency during initial invocation after a period of inactivity, known as a cold start.

Vendor Lock-In: Proprietary implementations by cloud providers can make it challenging to migrate applications between platforms.

Limited Execution Time: FaaS platforms often impose execution time limits, which may not be suitable for long-running processes.

Debugging and Monitoring: Observability can be more complex in serverless environments due to the ephemeral nature of functions.

The Role of CloudEvents

To address interoperability challenges, the Cloud Native Computing Foundation introduced CloudEvents, a specification for describing event data in a common format. By standardizing event metadata, CloudEvents facilitates integration between services and platforms, promoting portability and reducing vendor lock-in.

Use Cases for Serverless Computing

Event-Driven Applications: Applications that respond to events, such as file uploads or database changes, benefit from the reactive nature of serverless architectures.

Microservices: Serverless functions align well with microservices architectures, enabling modular and independently deployable components.

Data Processing: Tasks like image processing, data transformation, and real-time analytics can be efficiently handled by serverless functions.

Scheduled Tasks: Functions can be scheduled to run at specific intervals, making them suitable for cron jobs and periodic tasks.

Conclusion

Serverless computing represents a paradigm shift in application development, offering a model that emphasizes simplicity, scalability, and cost efficiency. While it introduces new considerations, such as cold starts and potential vendor lock-in, the benefits often outweigh the challenges for many use cases. As the ecosystem matures, standards like CloudEvents will play a crucial role in enhancing interoperability and reducing complexity.

Cloud-Native Applications: 7 Key Characteristics You Should Know

AugustineOzor — Tue, 29 Apr 2025 16:44:00 +0000

As more of us dive into building cloud-native apps, it's essential to understand what sets them apart. These applications are built to thrive in dynamic environments like the cloud—fast, resilient, scalable, and secure.

In this post, I’ll walk you through 7 core characteristics that define cloud-native applications in simple, real-world terms.

1. High Level of Automation

Automation is the heartbeat of cloud-native development. From writing code to testing and deploying it, automation helps you ship faster with fewer bugs.

Using tools like CI/CD pipelines (think GitHub Actions, GitLab CI, Jenkins) means:

Minimal manual effort
Quicker release cycles
Easier rollback or disaster recovery if something goes wrong

A well-automated workflow lets you focus more on building, and less on babysitting deployments.

2. Self-Healing Systems

Apps crash. Servers go down. It’s normal.

Cloud-native systems expect this and come prepared with built-in health checks and restart mechanisms. This means if one part of your app fails, the rest keeps running while the broken part fixes itself automatically.

It’s like your app has its own immune system.

3. Scalable by Design

Need to handle more traffic? No problem.

Cloud-native apps are built to scale up (add more resources when needed) and scale down (use fewer resources when things are quiet). This can happen automatically based on metrics like CPU usage or memory.

Think of it like adding more checkout lanes at a store when the line gets long—and closing them when it gets short.

4. Cost-Efficient

Scaling works both ways. If your app isn’t being used much, it can scale down—or even shut down temporarily. This is super helpful for saving on costs, especially with pay-as-you-go cloud models.

Using tools like Kubernetes helps optimize resource usage by smartly placing your workloads on available machines. More efficiency = lower bill!

5. Easy to Maintain

Cloud-native apps often use microservices, meaning your application is broken into smaller, manageable pieces. Each microservice:

Can be built and deployed independently
Is easier to test and debug
Can be handled by separate teams

This structure makes your app modular and maintainable—like having individual LEGO blocks instead of one giant glued-together brick.

6. Secure by Default

In traditional systems, once you’re “inside,” you can often access anything. But modern cloud environments follow a zero trust model.

This means every user and process has to prove who they are—every time.

Cloud-native security includes:

Fine-grained access controls
Encryption
Isolation between workloads

Security is baked in—not bolted on.

7. Autoscaling (Horizontal vs Vertical)

Autoscaling is one of the coolest cloud-native features.

Horizontal scaling means adding more machines or containers (e.g., more people lifting a heavy object).

Vertical scaling means giving more power (CPU/RAM) to your existing machine (e.g., building muscle to lift it yourself).

Most cloud providers support autoscaling based on metrics like:

CPU usage
Memory usage
Time of day
Custom business metrics

You define minimum and maximum limits and the system does the rest—scaling up when needed and shrinking down when it’s not.

Final Thoughts

Cloud-native applications aren’t just apps that run in the cloud—they’re designed to thrive there.

To summarize

Automate everything
Expect failure, and recover automatically
Scale smartly
Optimize cost and performance
Stay secure
Break apps into manageable parts

By embracing these principles, you’ll build apps that are faster, stronger, and smarter.

What part of cloud-native architecture do you find most challenging? Let me know in the comments!

Follow me for more practical posts on Cloud, DevOps, and Cybersecurity.

cloudnative #aws #devops #cloudcomputing #microservices #kubernetes #automation #security

Cloud Native Architecture: A Simple Introduction

AugustineOzor — Mon, 28 Apr 2025 18:31:43 +0000

When we hear "cloud native," it can sound like a buzzword — but at its core, it's about one thing: building better software for the cloud.

Cloud Native Architecture is about designing apps that are:

- Cost-efficient
- Reliable
- Fast to market

It’s not just about technology — it’s also a mindset shift.
The Cloud Native Computing Foundation defines it perfectly:

Cloud native technologies empower organizations to build and run scalable applications in modern, dynamic environments such as public, private, and hybrid clouds.

In simpler words: you're building apps that thrive in the cloud, using containers, service meshes, microservices, immutable infrastructure, and declarative APIs.

Traditional (Monolithic) vs Cloud Native (Microservices)

Old-school (legacy) apps were often monolithic all-in-one packages with everything (UI, product catalog, shopping cart, checkout) bundled tightly together.

Monoliths are simple to start with but painful to scale, update, or manage when complexity grows.

Now imagine breaking that massive app into smaller, independent pieces called microservices.
Each microservice:

- Handles just one job (like checkout or product listing)
- Can be scaled separately
- Can be updated independently
- Can be owned by different teams

If your checkout service suddenly gets slammed with traffic, you can scale just that service — no need to touch the whole app.

The Catch?

Cloud native isn't magic.
You need

- Good architecture practices
- Strong DevOps culture
- Observability
- Automation everywhere

More flexibility comes with more complexity.
But if done right, the payoff is huge.

Final Thoughts

Cloud native is more than just a tech trend, it's a new way of thinking about how we design, build, and scale applications for today's users.

If you’re stepping into cloud development or DevOps, understanding these principles early can seriously level up your career.

cloudnative #devops #microservices #cloudcomputing #softwarearchitecture #aws #kubernetes #devto

Understanding ACL and Special Permissions in Linux

AugustineOzor — Mon, 28 Apr 2025 15:10:03 +0000

Table of Contents

What is ACL (Access Control List)?
ACL Management Commands
What Are Special Permissions?
Types of Special Permissions
- SUID
- SGID
- Sticky Bit
Set Permissions Numerically
Conclusion

Description: Learn how to manage ACLs and set SUID, SGID, and Sticky Bit permissions in Linux. This is part of my RHCSA and Ansible training journey.

Understanding ACL and Special Permissions in Linux

When basic file permissions aren't enough, Linux offers more advanced options: Access Control Lists (ACLs) and Special Permissions like SUID, SGID, and the Sticky Bit.

These permissions are powerful tools for system admins, especially when managing shared directories, automation scripts, and user access on multi-user systems.

What is ACL (Access Control List)?

ACL allows you to assign different permission levels to individual users or groups for a file or directory — going beyond the basic user/group/others model.

ACL Management Commands

Command	Description
`getfacl <dir>`	View ACLs on a file or directory
`setfacl -m u:username:perm <dir>`	Add/modify user ACL permission
`setfacl -x u:username <dir>`	Remove ACL permission for a user
`setfacl -b <dir>`	Remove all ACL permissions
`setfacl -m g:groupname:perm <dir>`	Add/modify ACL for a group
`setfacl -x g:groupname <dir>`	Remove ACL for a group

What Are Special Permissions?

Special permissions are used for executables and shared directories to control how files behave during execution or deletion. These include

SUID (Set User ID)
SGID (Set Group ID)
Sticky Bit

Types of Special Permisssion

SUID (Set User ID)

When set on an executable file, it runs with the owner’s privileges, not the user's.

Command	Action
`chmod u+s file`	Set SUID
`chmod u-s file`	Remove SUID

Example
chmod u+s /usr/bin/special_script
Any user can run this script with root privileges (if owned by root).

SGID (Set Group ID)

When set on a directory, new files inside will inherit the directory's group, not the creator’s group.

Command	Action
`chmod g+s dir`	Set SGID
`chmod g-s dir`	Remove SGID

Example
chmod g+s /shared
All files created in /sharedinherit its group automatically.

Sticky Bit

Used on shared directories, it ensures that only the owner of a file can delete it — even if others have write access.

Command	Action
`chmod o+t dir`	Set Sticky Bit
`chmod o-t dir`	Remove Sticky Bit

Example:
chmod o+t /team/shared

Set Permissions Numerically

You can also apply special permissions using numbers

Type	Numeric Value	Example to Set
SUID	4	`chmod 4755 file`
SGID	2	`chmod 2755 dir`
Sticky Bit	1	`chmod 1755 dir`

To remove, subtract the leading digit
chmod 755 file # Removes SUID
If SUID is set, the execute permission for the owner (rws) shows s.
If removed, it shows normal execute (x) *or no execute *(-).

chmod -2000 dir # Removes SGID
If SGID is set, the group execute (rwx) **has an **s.
If removed, it's back to normal (x or -).

chmod -1000 dir # Removes Sticky Bit
If Sticky Bit is set, the others' execute permission shows t.
If removed, it will show just x or - **without the **t.

Conclusion

ACL and special permissions give you fine-grained control over who can access and execute files, beyond basic Linux permissions.

These are must-know tools for any Linux system admin especially in enterprise or multi-user environments. If you're pursuing RHCSA, working in DevOps, or managing shared infrastructure, these commands are essential!

Understanding File Permissions in Linux: A Beginner's Guide

AugustineOzor — Fri, 25 Apr 2025 05:28:12 +0000

** Table of Contents**

Business Use Case
What Are File Permissions?
Types of Permissions
Check File and Directory Permissions
Change Ownership of Files or Directories
Change File Permissions with chmod
- Remove Permissions
- Add Permissions
- Set Full or Specific Permissions
- Numeric Value of Permission
Conclusion

Description: Learn how to view and change file and directory permissions in Linux using chmod, chown, and chgrp with simple examples.

Linux controls access to files and directories using a permission system. Knowing how to check, change, and manage these permissions is essential for keeping your system secure and organized.

This guide breaks down the basics of file permissions and how to manage them using chmod, chown, and chgrp.

Business Use Case

Imagine you're a DevOps engineer at a company where multiple developers are working on different microservices. You want to ensure that

Each team has access only to their own service folder
No unauthorized user can modify critical deployment scripts
Logs are readable but not editable by non-admin users

What Are File Permissions?

File permissions in Linux control who can read, write, or execute a file or directory. These are usually defined for:

User (u) – The file owner
Group (g) – The group the file belongs to
Others (o) – Everyone else

Types of Permissions

Linux supports three main types of permission systems:

Basic Permissions – Most commonly used; includes r (read), w (write), and x (execute).
ACL (Access Control List) – More advanced, allowing fine-grained control.
Special Permissions – Includes setuid, setgid, and sticky bit (covered in later parts).

Check File and Directory Permissions

Check permissions of a file
ls -l filename to show the permission of a particular file

ls -ld Desktop - show the permissions of the Desktop directory.

Each part indicates permission for user, group, and others.

Change Ownership of Files or Directories

Change file/directory owner
chown username file_or_dir

From the screenshot the owner was student but the the command chown root file222.txt the own was changed to root.

Change group ownership
chgrp groupname directory - This command changes the group the directory belongs to.

Change both owner and group
chown user:group directory - This command changes both the owner and group of the directory

Change File Permissions with chmod

Remove Permissions

Command	Description
`chmod o-rwx dir`	Remove all permissions from others
`chmod g-rx dir`	Remove read and execute from group
`chmod u-w dir`	Remove write permission from user

i. chmod o-rwx food/ - remove all permissions from other to the food directory.ii.chmod g-rx dir1/ - remove read and execute permission from groupiii.chmod u-w gitclone/ - remove the write permission from the user.

Add Permissions

Command	Description
`chmod u+rwx dir`	Give user full permissions
`chmod ugo+rwx dir`	Give all users full permissions

i.chmod u+rwx dir1/ - this command will add read, write and execute permissions to dir1 directory.ii.chmod ugo+rwx food/

Set Full or Specific Permissions

Command	Description
`chmod u-rwx,g-rwx,o-rwx dir1/`	Remove all permissions from everyone
`chmod ugo=r-x dir`	Set read and execute permissions for all

i.chmod u-rwx,g-rwx,o-rwx dir1/ii.chmod ugo=r-x dir

Numeric Value of Permission

Each digit in a three-digit permission set (like 755) represents:
1st digit: User (owner)
2nd digit: Group
3rd digit: Others

Conclusion

File and directory permissions are one of the most important parts of Linux system administration. Learning how to check and set the right permissions helps keep your files secure and your system under control.
Practice with test files and get comfortable using chmod, chown, and ls -l.

Group Management in Linux: Create, Modify, and Manage Group Accounts Like a Pro

AugustineOzor — Mon, 21 Apr 2025 19:40:21 +0000

What is a Group in Linux?
Types of Groups
Where Group Data is Stored
Essential Group Management Commands
- Create a Group
- Check Group Properties
- Modify Group ID
- Add or Remove Group Members
- Add/Remove Multiple Users
- Assign a Group Admin
- Check Group Admins
- Delete a Group
Conclusion

Description
Learn how to manage groups in Linux using commands like groupadd, gpasswd, groupmod, and more. Includes clear examples and file references.

Groups in Linux help system administrators organize users, manage permissions, and control access more efficiently especially in multi-user environments like servers and enterprise systems.

In this guide, you’ll learn how to create, manage, and delete group accounts using real command-line examples.

What is a Group in Linux?

A group is a collection of user accounts. Groups are used to assign common permissions to multiple users and simplify system administration tasks.

For example, giving read/write access to a project folder for all members of the dev group is easier than setting permissions for each user individually.

Types of Groups

Group Type	Description
Primary Group	Automatically created when a new user is added. Each user belongs to exactly one primary group. Deleting the user also removes their primary group.
Secondary Group	Created and managed by superusers. Users can belong to multiple secondary groups for shared access to files or services.

Where Group Data is Stored

File	Purpose
`/etc/group`	Stores group account properties
`/etc/gshadow`	Stores group admin and secure group info

Essential Group Management Commands

Create a Group

groupadd testers - Creates a new group named testers

Check Group Properties

grep testers /etc/group - Displays group info like GID and members

Modify Group ID

groupmod -g 2025 testers - Changes the GID of the developers group to 2025

Add or Remove Group Members

gpasswd -a alice testers - Add a user to a group

Verify if alice is added to the testers group
cat /etc/group | grep testers

Remove a user from a group
gpasswd -d alice testers

Options you can use on `gpasswd`

Add/Remove Multiple Users to a Group

Current users

gpasswd -M seth,mike,rose,mary,helen testers

Note: Adds multiple users to the group. This replaces any existing members include all users (new + existing) to avoid removing others accidentally

Assign a Group Admin

gpasswd -A seth testers - Makes seth a group administrator for tester

Check Group Admins

grep testers /etc/gshadow - Shows who the group admins are

Delete a Group

groupdel testers - Deletes the testers group from the system.

When you run the command grep testers /etc/group, it returns no results because the testers group has already been deleted from the system.

Tip:
Use the man command to explore additional options and details for any command. For example, man useradd shows all available flags and usage examples.

Conclusion

Groups are essential for managing user permissions in an organized and efficient way especially in teams or multi-user systems.

User Management in Linux: A Beginner's Guide to Creating, Modifying, and Deleting Users

AugustineOzor — Fri, 18 Apr 2025 18:20:46 +0000

What is a User in Linux?
Types of Users
UID: Unique User ID Explained
Where User Data is Stored
Essential User Management Commands
- Create a New User
- Set or Change a Password
- Check User Properties
- Switch Between Users
- Delete a User
- Add a Group
- Tips

Managing users is a core skill for anyone working with Linux — whether you're running a local server or managing cloud infrastructure. In this guide, I break down the basics of Linux user accounts, from types and UIDs to creating, modifying, and deleting users.

What is a User in Linux?

A user is a login account on a Linux system that allows a person (or system process) to access the computer's resources. Each user has permissions that control what they can or can't do.

Types of Users

System User

Created automatically during OS installation
Typically used for running services and system processes
Examples: root, apache, daemon

Normal User

Created manually by an administrator
Used for human users to log in and run applications
Example: john, developer1

UID: Unique User ID Explained

Every user in Linux is assigned a UID (User Identifier)

UID Range	Description
0	Reserved for the root (superuser)
1–999	Reserved for system/service users
1000–60000	Normal user accounts

Where User Data is Stored

File	Purpose
`/etc/passwd`	Stores user account info
`/etc/shadow`	Stores user password and aging info

Essential User Management Commands

Create a New User

useradd james - Creates a new user account

Set or Change a Password

passwd james - Assigns or updates the password for a user.
You will be prompted to enter the password twice.

Check User Properties

grep james /etc/passwd - Displays account details.

Check Password Properties

grep james /etc/shadow - View password aging and security info for a user.

Switch Between Users

su james - Switches from the current user

Modify an Existing User

usermod -l newname oldname - Changes a username from oldname to newname.
usermod -l james daniel

Delete a User

userdel james - Delete user only
userdel -r james - Delete user and their home directory

Add a Group

groupadd itdepartment - Create a group

Add User to a Group

usermod -aG groupname username - Adds a user to a supplementary group.
usermod -aG itdepartment james

List All Groups a User Belong to
groups username
groups james

Tips

Use man or info on the command - These give detailed documentation right in the terminal. It’s like built-in help.

Managing users is an important part of working with Linux. Whether you’re adding new people to the system, setting up accounts for services, or removing old users, these commands make it easy to do the job with confidence.

DEV Community: AugustineOzor

Mastering User Management, Authentication, and Process Monitoring in Linux" published

Table of Contents

Switch Users and sudo Access

Switch User:

Run as Superuser

sudo command

Monitor Logged-In Users

Communicate with Logged-In Users

Linux Account Authentication

Account Types and Directory Services

Useful System Utility Commands

Processes and Jobs

Managing Services and Jobs

Efficient File Management in Linux

Table of Contents

Description

Comparing Files

Compressing and Uncompressing Files

Truncating File Size

Combining and Splitting Files

Mastering Linux Text Processing Commands: cut, awk, grep, and more

Table of Contents

Description

cut: Extracting Specific Parts of a Line

Common cut Examples:

awk: Field-Based Processing and Pattern Matching

Common awk Examples:

grep & egrep: Pattern Search

sort: Sorting Output

uniq: Finding Unique Lines

wc: Word, Line, and Character Count

Conclusion

Embracing Open Standards in Cloud-Native Development

Table of Contents

Description

Why Open Standards Matter

Key Open Standards in the Cloud-Native Ecosystem

Open Container Initiative (OCI)

Container Network Interface (CNI)

Container Runtime Interface (CRI)

Container Storage Interface (CSI)

Service Mesh Interface (SMI)

CNCF Project Maturity Levels

Sandbox Stage

Incubating Stage

Graduation Stage

Conclusion

Managing Files, Links, and Redirection in Linux

Table of Contents

Managing Files, Links, and Redirection in Linux — A Practical Guide

File Links in Linux

Soft Links (Symbolic)

Hard Links

Creating Links with ln

Input and Output Redirection

Standard Output (stdout)

Appending Output

Standard Input (stdin)

Standard Error (stderr)

Conclusion

Serverless Computing: Simplifying Cloud Development

Table of Contents

Descriptions

What Is Serverless Computing?

Function as a Service (FaaS)

Benefits of Serverless Computing

Challenges and Considerations

The Role of CloudEvents

Use Cases for Serverless Computing

Conclusion

Cloud-Native Applications: 7 Key Characteristics You Should Know

1. High Level of Automation

2. Self-Healing Systems

3. Scalable by Design

4. Cost-Efficient

5. Easy to Maintain

6. Secure by Default

7. Autoscaling (Horizontal vs Vertical)

Final Thoughts

`cut`: Extracting Specific Parts of a Line

Common `cut` Examples:

`awk`: Field-Based Processing and Pattern Matching

Common `awk` Examples:

`grep` & `egrep`: Pattern Search

`sort`: Sorting Output

`uniq`: Finding Unique Lines

`wc`: Word, Line, and Character Count

Creating Links with `ln`

Options you can use on `gpasswd`