DEV Community: Arpit Mungone

🐧 Linux for DevOps #2: Mastering Users, File Permissions & Process Management

Arpit Mungone — Mon, 06 Jul 2026 17:02:31 +0000

Welcome back to Part 2 of my Linux for DevOps series.

In my previous blog, I covered Linux fundamentals, the file system, and essential commands that every beginner should know. If there's one thing I've learned so far, it's that Linux isn't just about memorizing commands—it's about understanding how the operating system works.

This week, I explored three of the most important Linux administration concepts that every DevOps Engineer should master:

👤 User & Group Management
🔐 File Permissions
⚙️ Process Management

These concepts are used every day by system administrators and DevOps engineers to manage servers securely and efficiently.

Let's dive in!

👤 User & Group Management

Linux is a multi-user operating system, meaning multiple users can access the same system while maintaining their own files, permissions, and settings.

Managing users correctly is essential for maintaining both security and organization.

Types of Users
Root User

The root user has unrestricted access to the entire system. It can install software, modify system files, create users, and perform administrative tasks.

Because it has complete control over the system, it's recommended to avoid logging in as root for everyday work.

Regular User

A regular user has limited permissions and cannot make system-wide changes unless granted administrative privileges using sudo.

This follows the Principle of Least Privilege, which is a security best practice.

System Users

System users are created automatically by Linux for running services like Nginx, MySQL, Docker, and other background processes.

Important Files

Linux stores user and group information in a few important files.

/etc/passwd

Stores basic information about every user.

/etc/shadow

Stores encrypted passwords and password-related information.

/etc/group

Stores information about all user groups.

Understanding these files helps you troubleshoot authentication and permission issues more effectively.

Common User Management Commands

Create a new user:

sudo useradd arpit

Set a password:

sudo passwd arpit

Switch to another user:

su arpit

Check the current user:

whoami

Display user information:

id arpit

Create a group:

sudo groupadd developers

Add a user to a group:

sudo usermod -aG developers arpit

Delete a user:

sudo userdel arpit
DevOps Use Case

Imagine a development team deploying applications to a production server.

Instead of giving everyone root access, each developer gets their own account and is added to a deployment group with only the permissions they need.

This improves security, accountability, and makes auditing much easier.

🔐 Linux File Permissions

Permissions are one of Linux's strongest security features.

Every file and directory has permissions that determine who can read, write, or execute it.

You can view permissions using:

ls -l

Example output:

-rwxr-xr--

Let's break it down.

Owner → rwx
Group → r-x
Others → r--
Understanding Permissions
Read (r)

Allows viewing the contents of a file.

Write (w)

Allows modifying or deleting a file.

Execute (x)

Allows executing a file or entering a directory.

Numeric Permissions

Linux also represents permissions using numbers.

Number Permission
7 Read + Write + Execute
6 Read + Write
5 Read + Execute
4 Read Only
0 No Permission

Examples:

chmod 755 script.sh
chmod 644 file.txt
chmod 600 private_key.pem
Changing Ownership

Change the owner of a file:

sudo chown arpit file.txt

Change the group:

sudo chgrp developers file.txt
Why You Should Avoid chmod 777

One of the biggest mistakes beginners make is giving every user full permissions.

chmod 777 file.txt

Although it solves permission issues quickly, it creates serious security risks because anyone can modify or delete the file.

A better approach is to assign only the permissions that are actually required.

DevOps Use Case

When connecting to an AWS EC2 instance using SSH, the private key must have secure permissions.

chmod 400 my-key.pem

If the permissions are too open, SSH will refuse the connection to protect your credentials.

⚙️ Linux Process Management

Whenever you run an application, Linux creates a process.

Every running process has a unique Process ID (PID).

Understanding processes is essential because applications, web servers, databases, and containers all run as processes.

View Running Processes
ps -ef

This command displays all running processes.

Monitor Processes
top

This provides a real-time view of CPU usage, memory usage, and running processes.

For a more user-friendly interface, you can use:

htop
Stop a Process

Kill a process using its PID:

kill 1234

Forcefully terminate it:

kill -9 1234
Run a Process in the Background
command &

View background jobs:

jobs

Bring a process back to the foreground:

fg
Keep a Process Running After Logout
nohup python app.py &

This is especially useful when running applications on remote Linux servers.

DevOps Use Case

Suppose your Nginx server becomes unresponsive.

The first step is to identify the running process.

ps -ef | grep nginx

If necessary, restart the service.

sudo systemctl restart nginx

Being able to inspect and manage processes quickly is an essential troubleshooting skill for DevOps engineers.

Common Mistakes Beginners Make

Here are a few mistakes I encountered while learning:

Logging in as the root user for everything.
Using chmod 777 without understanding the security risks.
Forgetting to use sudo when administrative privileges are required.
Killing the wrong process by mistake.
Not checking file ownership before changing permissions.

Learning from these mistakes helped me better understand how Linux manages security and system resources.

Quick Command Cheat Sheet
User Management
whoami
id
useradd
passwd
usermod
userdel
groupadd
groups
File Permissions
ls -l
chmod
chown
chgrp
Process Management
ps -ef
top
htop
kill
kill -9
jobs
bg
fg
nohup
Key Takeaways

This week helped me understand that Linux administration isn't just about knowing commands—it's about managing systems securely and efficiently.

Here's what I learned:

How Linux manages users and groups.
Why file permissions are critical for security.
How ownership affects file access.
How to monitor and manage running processes.
Why following security best practices is essential in DevOps.

Every concept I learned this week is directly applicable to real-world cloud environments and production servers.

Thanks for reading!

If you're also learning Linux or DevOps, I'd love to hear about your journey. Feel free to share your thoughts, suggestions, or favorite Linux commands in the comments.

Happy Learning! 🚀

linux #devops #aws #beginners #cloud

Learning Linux from Scratch: My First Week in DevOps

Arpit Mungone — Mon, 22 Jun 2026 11:17:20 +0000

🚀 Week 1 of My DevOps Journey: Learning Linux Fundamentals and Essential Commands

Hello everyone! 👋

Welcome to Week 1 of my DevOps learning journey.

As a final-year BCA student specializing in Cloud Computing, I have decided to document my journey toward becoming a DevOps Engineer. This blog series will cover everything I learn, from Linux fundamentals to cloud computing, containers, CI/CD, Kubernetes, and monitoring tools.

Since Linux is the backbone of most DevOps environments, I decided to start my journey by learning Linux fundamentals and essential commands.

Why Linux Matters in DevOps

Most servers in cloud environments run Linux. Whether you're working with AWS EC2 instances, Docker containers, Kubernetes clusters, or CI/CD pipelines, Linux knowledge is essential.

As a DevOps Engineer, you'll frequently:

Manage Linux servers
Deploy applications
Troubleshoot issues
Monitor system performance
Automate tasks using shell scripts

That's why Linux is often considered the first skill every DevOps engineer should master.

What I Learned This Week

Understanding the Linux File System

One of the first things I learned was how Linux organizes files and directories.

Some important directories include:

/ – Root directory
/home – User home directories
/etc – Configuration files
/var – Logs and variable data
/tmp – Temporary files
/usr – User programs and utilities

Understanding the file system structure helps navigate servers more effectively.

Basic Navigation Commands

I practiced several commands used daily by Linux administrators.

Check Current Directory

pwd

List Files and Directories

ls
ls -l
ls -la

Change Directory

cd /home

Create Directory

mkdir project

Remove Directory

rmdir project

File Management Commands

Working with files is a common task in Linux.

Create a File

touch file.txt

Copy Files

cp file.txt backup.txt

Move Files

mv file.txt documents/

Delete Files

rm file.txt

View File Content

cat file.txt

Viewing System Information

I also learned how to check system details.

Check CPU Information

lscpu

Check Memory Usage

free -h

Check Disk Usage

df -h

Check Running Processes

ps -ef

Monitor Processes in Real Time

top

Understanding Permissions

Linux uses permissions to control access to files and directories.

I learned about:

Read (r)
Write (w)
Execute (x)

Viewing permissions:

ls -l

Changing permissions:

chmod 755 script.sh

Changing ownership:

chown user:user file.txt

Permissions are critical for maintaining system security.

Service Management

One interesting topic was managing services using systemctl.

Check Service Status

systemctl status nginx

Start a Service

systemctl start nginx

Stop a Service

systemctl stop nginx

Restart a Service

systemctl restart nginx

This is especially useful when managing web servers and applications.

Viewing Logs

Logs help identify issues and troubleshoot systems.

tail -f /var/log/messages

journalctl -xe

Understanding logs is one of the most important skills for troubleshooting production systems.

My First Bash Script

I wrote a simple script to check whether Nginx is running.

#!/bin/bash

if systemctl is-active --quiet nginx
then
    echo "Nginx is running"
else
    echo "Nginx is not running"
fi

This helped me understand:

if-else conditions
shell scripting basics
automation concepts

It was my first step toward infrastructure automation.

Challenges I Faced

During my learning, I encountered a few challenges:

Understanding Linux permissions
Navigating directories quickly
Reading system logs
Writing Bash scripts correctly

After practicing commands repeatedly and experimenting on AWS EC2 instances, these concepts became much clearer.

Key Takeaways

This week taught me that Linux is much more than just a command-line operating system.

I learned:

✅ Linux file system structure

✅ Essential Linux commands

✅ File and directory management

✅ System monitoring basics

✅ Service management

✅ Log analysis

✅ Bash scripting fundamentals

Most importantly, I realized that strong Linux fundamentals make learning DevOps tools much easier.

What's Next?

In Week 2, I plan to learn:

Advanced Linux Commands
User and Group Management
Networking Basics
SSH and Remote Access
Package Management
More Bash Scripting

Final Thoughts

Every DevOps Engineer starts somewhere, and Linux is the perfect place to begin.

This week gave me a solid foundation and increased my confidence in working with servers and cloud environments. I'm excited to continue learning and sharing my progress through this blog series.

If you're also starting your DevOps journey, feel free to connect and share your experiences.

See you in Week 2! 🚀

linux #devops #aws #cloudcomputing #bash #opensource #learninginpublic #career