DEV Community: Arpit Mungone

🌐 Linux for DevOps #3: Understanding Linux Networking Through Hands-On Practice

Arpit Mungone — Sat, 08 Aug 2026 11:32:26 +0000

Welcome back to my DevOps learning journey! 👋

For the past two weeks, I've been building my Linux foundation.

In Week 1, I learned how to navigate Linux and work with essential commands.

In Week 2, I explored users, groups, file permissions, and process management.

This week, I decided to move one step further and understand something that I kept encountering everywhere in DevOps:

Networking.

At first, networking felt like a completely different world.

IP addresses, ports, DNS, TCP, UDP, routing, connectivity...

There were a lot of terms to remember.

But once I started practicing networking commands directly on Linux and connecting them with things I had already worked with in AWS, the picture started becoming much clearer.

I realized something important:

As a DevOps engineer, you don't need to become a network engineer, but you absolutely need to understand how systems communicate.

So, this week, I focused on the Linux networking commands that I believe every aspiring DevOps engineer should know.

🌐 What Exactly Is Linux Networking?

Before jumping into commands, I wanted to understand the basics.

Networking is essentially about communication between systems.

When I open a website, connect to an AWS EC2 instance through SSH, pull a Docker image, or make an API request, different systems are communicating with each other.

Linux provides several tools that allow us to inspect and troubleshoot this communication.

And that's where the command line becomes extremely useful.

🖥️ 1. Finding My IP Address

One of the first things I wanted to understand was:

"What is my machine's IP address?"

The command I used was:

ip addr

It displays information about the network interfaces available on the machine.

For example, you might see something like:

inet 192.168.1.10/24

Here, 192.168.1.10 is the IP address assigned to the interface.

Another simple command I found useful was:

hostname -I

It gives the IP addresses assigned to the system in a much simpler format.

Why is this useful in DevOps?

When working with servers, especially AWS EC2 instances, knowing the server's IP address is fundamental.

For example:

ssh -i my-key.pem ec2-user@<IP_ADDRESS>

Without understanding the IP address, it's difficult to understand how we're actually reaching the server.

🔁 2. Understanding Localhost

One concept I wanted to understand better was localhost.

You will often see:

127.0.0.1

This is the IPv4 loopback address.

It refers to the machine itself.

For example, if I run a web application on:

127.0.0.1:5000

the application is accessible from the same machine through port 5000.

I can test it using:

curl http://127.0.0.1:5000

This became particularly interesting when I started working with applications, Docker, and web servers.

It helped me understand the difference between:

"Is my application running?"

and

"Can other machines reach my application?"

Those are two completely different questions.

📡 3. Testing Connectivity with `ping`

One of the first networking commands almost everyone learns is:

ping google.com

The command sends ICMP echo requests to check whether the destination is reachable.

A typical response might look like:

64 bytes from ...
time=20 ms

The time value gives an indication of the round-trip latency.

What can `ping` tell me?

It can help answer questions like:

Can I reach the destination?
Is there packet loss?
Is the network responding?
How much latency is there?

However, one important lesson I learned is:

A failed ping doesn't always mean the server is down.

Some servers and firewalls simply block ICMP traffic.

This is important when troubleshooting cloud environments.

🌍 4. Understanding DNS with `nslookup`

I used to think DNS was simply "the thing that converts domain names into IP addresses."

But while practicing, I started understanding how important it is.

For example:

nslookup google.com

This allows us to query DNS and find the IP address associated with a domain.

Another useful command is:

dig google.com

dig provides more detailed DNS information and is especially useful for troubleshooting.

Why does DNS matter in DevOps?

Imagine your application works when you access:

http://192.168.1.20

but doesn't work when you access:

http://myapp.example.com

The application might be completely fine.

The problem could simply be DNS.

This is why understanding DNS is important when deploying applications and services.

🌐 5. Using `curl` to Test Applications

curl quickly became one of my favorite networking commands.

For example:

curl https://example.com

This sends an HTTP request and displays the response.

But curl is much more useful than simply opening websites.

I can use it to test APIs:

curl http://localhost:5000/api/users

I can also inspect HTTP headers:

curl -I https://example.com

This can help me understand:

HTTP status codes
Server responses
Redirects
Headers
Application availability

A practical DevOps scenario

Suppose I deployed an application behind Nginx.

Instead of immediately assuming the application is broken, I can test it step by step:

curl http://localhost

If that works, I know the web server is responding.

Then I can investigate whether the issue is related to DNS, security groups, load balancers, or something else.

📥 6. `wget` – Downloading Files

Another command I practiced was:

wget https://example.com/file.zip

wget is commonly used to download files directly from the command line.

This can be useful when working with Linux servers where there is no graphical browser.

For example, I might need to download:

Configuration files
Application packages
Scripts
Software archives

It's a simple command, but very useful when working on remote servers.

🔌 7. Understanding Ports

This was one of the concepts I found particularly important.

An IP address tells us which machine we're communicating with.

A port helps identify which service we're trying to communicate with on that machine.

Some common ports are:

Port	Common Usage
22	SSH
80	HTTP
443	HTTPS
3306	MySQL
5432	PostgreSQL
8080	Common application/web port

For example:

192.168.1.10:80

means we're trying to reach port 80 on that machine.

🔎 8. Checking Listening Ports with `ss`

One of the most useful commands I learned was:

ss -tuln

This helps display listening network sockets.

The options mean:

t → TCP
u → UDP
l → Listening
n → Don't resolve service names

If Nginx is running, I might see port 80 listening.

This gives me a very useful troubleshooting question:

Is the application actually listening on the port I'm trying to access?

That's much better than randomly restarting services and hoping they work.

🧭 9. Understanding Network Routes

Another command I explored was:

ip route

This shows the routing table used by Linux.

It helped me understand that packets don't simply "go to the internet."

Linux needs to know where traffic should be sent and which interface or gateway should be used.

For example, you might see:

default via 192.168.1.1 dev eth0

The default route tells Linux where to send traffic when there isn't a more specific route available.

🛣️ 10. Tracing Network Paths

I also explored:

traceroute google.com

This attempts to show the path packets take through the network to reach the destination.

This can be useful when troubleshooting where connectivity problems might be occurring.

Depending on the environment, traceroute may need to be installed first.

🧪 Putting Everything Together

This is where networking became much more interesting for me.

Instead of memorizing commands individually, I started thinking about them as a troubleshooting workflow.

Imagine I deploy a web application, but I can't access it.

Instead of immediately restarting everything, I can ask a series of questions.

Step 1 — Is the server reachable?

ping <server-ip>

Step 2 — Is the application listening?

ss -tuln

Step 3 — Can I reach the application locally?

curl http://localhost:8080

Step 4 — Is DNS resolving?

nslookup myapp.example.com

or:

dig myapp.example.com

Step 5 — What routes are being used?

ip route

This way, troubleshooting becomes a process instead of guesswork.

And I think that's one of the biggest things I'm learning from DevOps:

Good troubleshooting starts with asking the right questions.

☁️ Connecting This to AWS

Learning Linux networking also made some AWS concepts easier to understand.

For example, when I work with an EC2 instance, several networking components come into play:

Private IP
Public IP
Security Groups
Ports
Routing
Internet Gateway
Subnets

If I can't connect to an EC2 instance through SSH, the problem might not be Linux itself.

It could be:

My Computer
     ↓
Internet
     ↓
AWS Security Group
     ↓
EC2 Network Interface
     ↓
Port 22
     ↓
SSH Service

Understanding Linux networking gives me a much better foundation for understanding what happens inside the server.

🤔 What I Learned This Week

The biggest lesson for me wasn't actually learning ping, curl, or ss.

It was learning how to think about connectivity.

Before this week, if an application wasn't opening, I might have immediately assumed:

"The application is broken."

Now I try to break the problem down:

Can I reach the server?

↓

Is DNS working?

↓

Is the required port open?

↓

Is something listening on that port?

↓

Is the application responding locally?

↓

Is there a firewall, security group, or routing issue?

This way of thinking is something I want to carry forward into my DevOps career.

🛠️ Commands I Practiced This Week

Here's my Linux networking cheat sheet:

# Network interfaces
ip addr
hostname -I

# Connectivity
ping google.com

# DNS
nslookup google.com
dig google.com

# HTTP requests
curl https://example.com
curl -I https://example.com

# Download files
wget https://example.com/file.zip

# Listening ports
ss -tuln

# Routing
ip route

# Trace network path
traceroute google.com

🚀 Key Takeaways

This week helped me understand that networking isn't just about memorizing protocols and port numbers.

It's about understanding how systems communicate and, more importantly, how to troubleshoot when they don't.

My main takeaways:

✅ IP addresses identify systems.

✅ Ports help identify services.

✅ DNS translates human-readable names into IP addresses.

✅ curl is extremely useful for testing applications and APIs.

✅ ss helps identify listening network services.

✅ ip route helps understand how Linux routes traffic.

✅ Troubleshooting should be systematic rather than based on guesses.

📚 Linux for DevOps Series

🐧 Part 1: Learning Linux from Scratch: My First Week in DevOps

🐧 Part 2: Users, File Permissions & Process Management

🌐 Part 3: Understanding Linux Networking (You are here)

🔜 Part 4: Bash Scripting — From Commands to Automation

What's Next?

Now that I have a better understanding of how Linux systems communicate, I want to take the next step:

Automation.

In the next part of this series, I'll start exploring Bash Scripting and see how I can turn repetitive Linux tasks into simple automated workflows.

I'm still learning, still making mistakes, and still figuring things out—but that's exactly what makes this journey interesting.

If you're also learning Linux, DevOps, or Cloud, I'd love to hear what you're currently working on.

Let's learn and build together. 🚀

linux #devops #networking #aws #cloudcomputing #bash #learninginpublic

🐧 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

DEV Community: Arpit Mungone

🌐 Linux for DevOps #3: Understanding Linux Networking Through Hands-On Practice

🌐 What Exactly Is Linux Networking?

🖥️ 1. Finding My IP Address

Why is this useful in DevOps?

🔁 2. Understanding Localhost

📡 3. Testing Connectivity with ping

What can ping tell me?

🌍 4. Understanding DNS with nslookup

Why does DNS matter in DevOps?

🌐 5. Using curl to Test Applications

A practical DevOps scenario

📥 6. wget – Downloading Files

🔌 7. Understanding Ports

🔎 8. Checking Listening Ports with ss

🧭 9. Understanding Network Routes

🛣️ 10. Tracing Network Paths

🧪 Putting Everything Together

Step 1 — Is the server reachable?

Step 2 — Is the application listening?

Step 3 — Can I reach the application locally?

Step 4 — Is DNS resolving?

Step 5 — What routes are being used?

☁️ Connecting This to AWS

🤔 What I Learned This Week

🛠️ Commands I Practiced This Week

🚀 Key Takeaways

📚 Linux for DevOps Series

What's Next?

linux #devops #networking #aws #cloudcomputing #bash #learninginpublic

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

linux #devops #aws #beginners #cloud

Learning Linux from Scratch: My First Week in DevOps

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

Why Linux Matters in DevOps

What I Learned This Week

Understanding the Linux File System

Basic Navigation Commands

File Management Commands

Viewing System Information

Understanding Permissions

Service Management

Viewing Logs

My First Bash Script

Challenges I Faced

Key Takeaways

What's Next?

Final Thoughts

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

📡 3. Testing Connectivity with `ping`

What can `ping` tell me?

🌍 4. Understanding DNS with `nslookup`

🌐 5. Using `curl` to Test Applications

📥 6. `wget` – Downloading Files

🔎 8. Checking Listening Ports with `ss`