DEV Community: Sreekanth Kuruba

How CoreDNS Powers Service Discovery in Kubernetes

Sreekanth Kuruba — Tue, 23 Jun 2026 12:00:47 +0000

CoreDNS is the DNS server that powers service discovery in Kubernetes. This post explains how Pods translate service names into IP addresses, explores common DNS records, and provides practical troubleshooting commands for debugging connectivity issues.

In the previous post, we learned how Kubernetes Services provide stable virtual IPs for Pods.

But another question remains:

How do applications find those Services?

Applications rarely communicate using IP addresses. Instead, they use names such as:

backend-service
mysql-service
redis-service

So how does a Pod translate those names into IP addresses?

That's where CoreDNS comes in.

Why Do We Need DNS in Kubernetes?

Imagine a frontend application connecting to a backend service.

Without DNS:

Backend IP = 10.96.15.21

If the Service IP changes, the application configuration must change.

With DNS:

backend-service

CoreDNS automatically resolves the name to the correct Service IP.

This allows applications to communicate without knowing actual IP addresses.

What Is CoreDNS?

CoreDNS is the DNS server running inside the Kubernetes cluster.

It watches Kubernetes resources and automatically creates DNS records for:

Services
Pods (optional)
Namespaces

Applications can then use service names instead of IP addresses.

Where Does CoreDNS Run?

CoreDNS runs as Pods inside the kube-system namespace.

Verify this with:

kubectl get pods -n kube-system

Typical output:

coredns-xxxxx
coredns-yyyyy

Multiple replicas provide high availability.

How Service Discovery Works

Suppose we have:

Service Name: backend-service
Namespace: default
ClusterIP: 10.96.15.21

A Pod sends:

backend-service

CoreDNS resolves it to:

10.96.15.21

The application never needs to know the actual IP address.

Kubernetes DNS Naming

Every Service receives a fully qualified domain name (FQDN):

service-name.namespace.svc.cluster.local

Example:

backend-service.default.svc.cluster.local

Most applications use the shorter name:

backend-service

Kubernetes automatically appends the remaining DNS suffix.

DNS Lookup Flow

Application Pod
        ↓
DNS Query
        ↓
CoreDNS
        ↓
Service ClusterIP
        ↓
kube-proxy
        ↓
Backend Pod

The entire process usually takes only a few milliseconds.

Important DNS Records

ClusterIP Service

CoreDNS returns the Service IP:

backend-service → 10.96.15.21

Headless Service

If the Service uses:

clusterIP: None

CoreDNS returns individual Pod IPs:

database-0
database-1
database-2

This is commonly used by StatefulSets.

Common DNS Problems and Solutions

1. Service name not resolving?

Verify the Service exists:

kubectl get svc

2. Test DNS from a Pod

kubectl exec -it <pod> -- nslookup backend-service

3. Check CoreDNS Pods

kubectl get pods -n kube-system

4. View CoreDNS Logs

kubectl logs -n kube-system deployment/coredns

Why CoreDNS Matters

Without CoreDNS:

Applications would need hardcoded IP addresses
Configuration changes would happen frequently
Service discovery would become difficult
Microservices communication would break easily

CoreDNS makes Kubernetes applications independent of changing IP addresses.

Summary

Pods communicate using names, not IP addresses.

CoreDNS acts as the phonebook of Kubernetes, translating Service names into IP addresses.

Understanding CoreDNS helps you:

Debug service discovery problems
Troubleshoot application connectivity
Understand Kubernetes networking better
Build resilient microservices

Next in the Series:

Ingress Explained – How External Traffic Enters Your Kubernetes Cluster.

Linux Networking Basics for Beginners

Sreekanth Kuruba — Tue, 23 Jun 2026 05:18:20 +0000

Most Linux “server down” problems are not actually system failures.

They are network issues.

👉 The system is running fine
👉 But it cannot talk to the outside world

That’s why networking is one of the most critical skills in Linux, DevOps, and cloud environments.

Let’s simplify it.

Basic Networking Concepts (Must Know First)

What is an IP Address?

An IP address is a unique address assigned to a device in a network.

Example:

192.168.1.10

👉 Used for communication between systems.

What is localhost (127.0.0.1)?

localhost refers to your own computer.

127.0.0.1

👉 This means “your own computer”

Used for:

testing apps
local development
debugging services

What is DNS?

DNS (Domain Name System) converts domain names into IP addresses.

Example:

google.com → 142.x.x.x

👉 Without DNS, we would need to remember IPs manually.

What is a Port?

Ports are like “doors” for services.

Ports are communication endpoints used by applications.

Examples:

Port 80 → HTTP
Port 443 → HTTPS
Port 22 → SSH

👉 One server can run multiple services using different ports.

1. Check Internet Connectivity with `ping`

ping google.com

Limit requests:

ping -c 4 google.com

👉 First command used in troubleshooting.

Checks:

is host reachable?
is network working?

2. Test Web Requests with `curl`

curl google.com

Headers only:

curl -I google.com   # Show only HTTP headers

Verbose mode:

curl -v google.com   # Verbose (detailed output)

Used for:

API testing
checking web services
debugging HTTP issues

3. Check DNS Resolution

nslookup google.com

# More detailed DNS lookup
dig google.com

👉 If DNS fails:

website won’t open
even if internet is working

4. Check Your IP Address

ip a          # full network interface details
hostname -I   # Show only IP addresses

👉 Shows your system’s network identity

5. Check Routing path

ip route
ip route | grep default   # Show default gateway

👉 Shows how traffic leaves your system

6. Check Open Ports

ss -tuln               # Show listening ports
ss -tuln | grep :80    # Check specific port

Shows which services are listening on your system.

Modern replacement for netstat.

7. Trace Network Path with `traceroute`

traceroute google.com

Install if needed:

sudo apt install traceroute    # Ubuntu/Debian
sudo dnf install traceroute    # Fedora/RHEL

👉 Shows where delay or failure happens in network path

8. Enhanced Traceroute with `mtr`

mtr is a powerful combination of ping and traceroute. It continuously monitors the connection.

mtr google.com

Install if needed:

sudo apt install mtr

👉 Combines:

ping
traceroute

Real-time network diagnostics tool

Simple Troubleshooting Flow (VERY IMPORTANT)

ping 8.8.8.8 → check internet
ping google.com → check DNS
ip a → check IP
ip route → check routing
curl -I site → check HTTP
traceroute / mtr → find failure point

👉 This is real DevOps incident workflow

⚠️ Common Beginner Mistakes

assuming internet is down (when DNS is broken)
not checking IP address first
using old tools (ifconfig, netstat)
routing checks

Simple Mental Model

Think of networking like delivery:

IP → house address
DNS → contact name → address lookup
Port → door number
Routing → delivery path
ping → “are you there?”

Summary

You learned:

IP address basics
localhost (127.0.0.1)
DNS resolution
ports (80, 443, 22)
ping → connectivity
curl → web/API testing
nslookup, dig → DNS tools
ip a, ip route → network config
ss → open ports
traceroute, mtr → path debugging

Why This Matters

Networking is the backbone of:

cloud systems
DevOps pipelines
APIs
production servers

👉 If networking breaks, everything breaks

Next Post:
Linux Logs Explained Simply,(journalctl, /var/log)

Question for You

Have you ever faced a situation where:

internet was working
but website still didn’t load?

That’s usually DNS — I’ll show debugging in Part 8.

Real production lesson: Logs can fill a server faster than applications. Always monitor /var/log growth before it becomes an outage. #sre #devops

Sreekanth Kuruba — Mon, 22 Jun 2026 11:33:25 +0000

Real production lesson: Logs can fill a server faster than applications. Always monitor /var/log growth before it becomes an outage. #sre #devops

Sreekanth Kuruba — Mon, 22 Jun 2026 11:33:02 +0000

SSH Sessions Dropping Frequently? Here's Exactly How I Troubleshoot It

Sreekanth Kuruba — Sat, 20 Jun 2026 07:56:43 +0000

Ever had your SSH session disconnect right in the middle of a production deployment?

I have.

After getting burned by it a few times, I created a simple troubleshooting checklist that helps me quickly find the root cause.

You're in the middle of a critical deployment or debugging session on a production server.

Suddenly:

Connection to 172.20.10.5 closed by remote host.

You reconnect… and it happens again 5 minutes later.

If this sounds familiar, you're not alone. SSH disconnections are one of the most frustrating issues for developers and DevOps engineers.

Here's the exact checklist I use to diagnose and fix recurring SSH disconnect problems.

1. Check Network Connectivity First

ping <server-ip>
traceroute <server-ip>
mtr <server-ip>          # Great for intermittent network issues

Look for:

Packet loss
High latency
Unstable VPN connections
ISP connectivity issues

Sometimes the problem isn't the server at all.

2. Check Server Resource Usage

Overloaded servers often become unresponsive and can drop SSH sessions.

top
htop
free -h
uptime

Pay special attention to:

High load average
Very low available memory
OOM (Out Of Memory) Killer activity
CPU saturation

3. Check SSH Logs

SSH logs often tell you exactly why the connection was terminated.

Ubuntu/Debian

sudo tail -f /var/log/auth.log

RHEL/CentOS/Rocky

sudo tail -f /var/log/secure

Modern systems

sudo journalctl -u sshd -f

Look for:

Timeout messages
Authentication failures
SSH daemon restarts
Connection errors

4. Fix SSH Timeout Settings (Server Side)

Edit the SSH daemon configuration:

sudo nano /etc/ssh/sshd_config

Add or modify:

ClientAliveInterval 300
ClientAliveCountMax 3

This means:

Send a keepalive packet every 300 seconds.
Disconnect only after 3 failed responses.

Restart SSH:

sudo systemctl restart sshd

5. Configure Client-Side Keepalive

Create or edit:

nano ~/.ssh/config

Add:

Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3

This helps prevent many idle SSH disconnections.

6. Check Firewalls, VPNs & Load Balancers

Some common culprits:

Firewall idle timeouts
Cloud load balancer timeouts
VPN session timeouts
NAT session expiration

Always troubleshoot the entire network path, not just the server.

7. Use `tmux` or `screen` (A Life Saver)

tmux
# Do your work
Ctrl + B then D   # Detach
tmux attach       # Reconnect later

This is a must-have habit for anyone working on Linux servers.

Even if your SSH session disconnects, your processes keep running.

8. Check System Limits

ulimit -a
cat /etc/security/limits.conf

Low limits can sometimes cause unexpected connection issues under heavy load.

Bonus Tip: Enable SSH Debugging

If the issue is difficult to reproduce:

ssh -vvv user@server-ip

The verbose output often reveals:

Authentication issues
Timeout problems
Network interruptions
Key exchange failures

A Real Production Incident

During a late-night deployment, our SSH sessions kept disconnecting every 3–4 minutes.

We initially suspected the server itself. CPU and memory looked fine, and SSH logs showed nothing unusual.

The actual culprit?

A firewall between our workstation and the server had an aggressive idle timeout configured.

Increasing the timeout and enabling SSH keepalives fixed the issue completely.

That incident taught me an important lesson:

Don't just troubleshoot the server. Troubleshoot the entire path between your machine and the server.

My SSH Troubleshooting Flow

SSH Keeps Disconnecting
        ↓
1. Network (ping/mtr)
        ↓
2. Server Resources (top/free)
        ↓
3. SSH Logs
        ↓
4. Timeout Settings (Server + Client)
        ↓
5. Firewall / LB / VPN
        ↓
6. Use tmux (always)

Final Thoughts

Most SSH disconnections usually come down to:

Idle timeout settings
Unstable network connections
Resource exhaustion
Firewall or VPN timeouts
Missing keepalive configuration

One final tip: I never perform deployments directly in a normal SSH session anymore.

Everything runs inside tmux.

Even if my connection drops, my work keeps running.

Have you ever faced a strange SSH disconnect issue? I'd love to hear your experience in the comments.

Linux Disk Usage Explained Simply

Sreekanth Kuruba — Wed, 17 Jun 2026 03:00:00 +0000

One of the fastest ways to break a Linux system is this:

❌ Running out of disk space

When disk fills up:

apps crash
logs stop writing
deployments fail
servers become unstable

👉 That’s why disk usage monitoring is critical in Linux and DevOps.

Let’s simplify it.

Disk Usage Basics (You Must Know This First)

What is Storage in Linux?

Storage is where Linux keeps:

Files
Applications
Logs
Databases

Examples:

HDD
SSD
Cloud volumes (AWS, etc.)

If storage becomes full:

Applications may crash
Logs may stop writing
System can become unstable

Linux uses storage through filesystems.

What is a Filesystem?

A filesystem is how Linux organizes storage.

Examples:

ext4
xfs

Linux mounts filesystems into directories like:

/
/home
/var

File Size vs Disk Usage

File size → Size of a single file
Disk usage → Total space consumed by files and directories

Commands:

ls -lh → Check file size
du -sh → Check directory disk usage

What is Mounting?

Linux attaches storage devices to directories using a process called mounting.

Examples:

/ → Main filesystem
/home → User files
/var → Logs and application data

This is why df -h shows a Mounted on column.

1. Check Overall Disk Usage with `df`

df -h

Example Output:

Filesystem      Size  Used  Avail  Use%  Mounted on
/dev/sda1        50G   32G   18G   65%   /

Meaning:

Size → Total disk
Used → used space
Avail → Free space
Use% → usage percentage
Mounted on → where disk is attached

👉 First command to run when server behaves weirdly.

2. Check Folder and Directory Size with `du`

du -sh /home
du -sh /var/log

-s → Summary (total size only)
-h → Human readable (KB, MB, GB)

👉 Used to find which folder is consuming space

3. Find Large Files in the System

find / -type f -size +100M 2>/dev/null
find / -type f -size +500M 2>/dev/null

⚠️ Can take time on large systems.

👉 Common use:

large logs
backups
unused media files

4. Find Biggest Directories (Very Important)

du -sh /* 2>/dev/null | sort -hr | head -n 10

👉 Shows top 10 largest directories

This is one of the most used DevOps troubleshooting commands.

5. Disk Full but Space Looks Free? (INODES)

df -i

What are inodes?

Inodes store metadata about files.

👉 Problem:

Disk shows free space
But system says:

No space left on device

👉 Cause:
Too many small files.

This is very common in:

log systems
microservices
temp file-heavy apps

6. Deleted Files Still Using Space

lsof | grep deleted

👉 Happens when:

file is deleted
but process is still using it

So disk space is NOT freed.

Bonus Tool: `ncdu` (Best for Beginners)

sudo apt install ncdu   # Ubuntu/Debian
sudo dnf install ncdu   # Fedora/RHEL

Run:

ncdu /

Why it’s powerful:

interactive UI
easy navigation
visual disk breakdown

👉 Widely used by DevOps engineers for fast debugging

Basic Cleanup Tips

Remove old logs carefully
delete unused backups
Clear package cache when needed
Always verify before using rm -rf

⚠️ Common Beginner mistakes

Disk shows free space but system says full → Check inodes (df -i)
using rm -rf without checking size
ignoring /var/log growth

Simple Mental Model

Think of disk like a room:

/home → personal items
/var → messy logs piling up
/usr → installed apps
/tmp → temporary trash

👉 When room is full → system slows down

Summary

In this guide you learned:

df -h → Overall disk usage
du -sh → Folder size
find → Locate large files
df -i → Check inodes
lsof | grep deleted → Find deleted open files
ncdu → Interactive disk usage analyzer

Why This Matters

Disk issues are one of the most common production failures in:

DevOps systems
cloud servers
databases
CI/CD pipelines

👉 Knowing this = real-world Linux skill

Next Post:
Linux Networking Basics for Beginners,(ping, curl, ip, ss, etc.)

Question for You

Have you ever faced a server where disk was full but you couldn’t find why?

That’s usually inode or deleted file issues — I’ll show debugging tricks in Part 7.

How Does Traffic Actually Reach Your Pods? Kubernetes Services & kube-proxy Explained

Sreekanth Kuruba — Tue, 16 Jun 2026 08:29:38 +0000

Your backend Pod just crashed.

Kubernetes created a new Pod with a completely different IP address.

Yet your application didn't notice anything changed.

How?

Because applications don't talk directly to Pods.

They talk to Kubernetes Services.

A Service provides a stable virtual IP and DNS name, while kube-proxy quietly programs the networking rules that route traffic to the right Pods.

In this post, we'll go beyond the usual "Service types" explanation and look at how traffic actually reaches your Pods under the hood.

What is a Kubernetes Service?

A Service provides a stable virtual IP (ClusterIP) and DNS name for a dynamic set of Pods.

Think of it as a permanent front door for Pods that may come and go.

Key points:

Services provide a stable endpoint for applications.
Pods behind a Service can change without affecting clients.
Services use labels and selectors to automatically discover matching Pods.
The Service IP is virtual—there is no process directly listening on that IP.

Important:

A ClusterIP doesn't belong to a real network interface, and no process is directly listening on that IP.

Instead, kube-proxy programs networking rules on every node so packets sent to the ClusterIP are transparently redirected to backend Pods.

How Does a Service Find Its Pods?

Kubernetes uses labels and selectors to determine which Pods belong to a Service.

Example:

Service selector:
app=backend

Matching Pods:
app=backend

Non-matching Pods:
app=frontend

Only the matching Pods become Service endpoints and receive traffic from the Service.

Why Do We Need Services?

Imagine a Deployment with three Pods:

backend-1 → 10.244.1.5
backend-2 → 10.244.2.8
backend-3 → 10.244.3.12

If backend-2 crashes, Kubernetes creates:

backend-4 → 10.244.2.15

The old IP disappears.

Without Services, every client would need to know the new Pod IPs constantly.

Services solve this problem by giving applications a stable endpoint.

Types of Kubernetes Services

1. ClusterIP (Default)

Accessible only inside the cluster.
Used for communication between microservices.

2. NodePort

Exposes the application on a port of every Kubernetes node.
Useful for testing and simple external access.

3. LoadBalancer

Creates an external load balancer using your cloud provider.
Commonly used for production applications.

4. ExternalName

Maps a Service to an external DNS name using a CNAME record.
Useful for integrating external services.

How Services Work Under the Hood

When you create a Service:

Kubernetes allocates a ClusterIP.
Kubernetes creates EndpointSlices, which contain the healthy Pod IPs behind the Service.
kube-proxy running on every node watches for Service and EndpointSlice changes.
kube-proxy programs networking rules on the node.
Traffic sent to the Service IP is automatically redirected to one of the backend Pods.

kube-proxy: The Unsung Hero

Many people think kube-proxy forwards packets itself.

It doesn't.

Its job is to configure the node's networking rules so Linux can route traffic efficiently.

kube-proxy can run in three modes:

iptables Mode

Most common deployment mode.
Uses iptables rules for load balancing and NAT.

IPVS Mode

Uses Linux IP Virtual Server.
Better scalability and performance for large clusters.

Userspace Mode

Legacy mode.
Rarely used today.

Traffic Flow Example

Client Pod
      ↓
Service (ClusterIP)
      ↓
kube-proxy Rules
      ↓
┌─────┬─────┬─────┐
Pod A Pod B Pod C

When a request is sent to a Service:

The packet reaches a node.
kube-proxy's rules match the Service IP and port.
Destination NAT (DNAT) redirects the request to one of the healthy Pods.
The Pod sends the response back to the client.

All of this happens transparently.

The client thinks it is communicating with a single stable IP.

Common Service Problems

Pods are not receiving traffic?

Check whether labels match the Service selector.

kubectl describe service <service-name>
kubectl get endpointslices

No backend Pods found?

Verify the Pods are Ready.

kubectl get pods -o wide

Debug kube-proxy Rules

ipvsadm -Ln
iptables -t nat -L KUBE-SERVICES -n

Fun Fact

Some modern networking solutions like Cilium can replace kube-proxy entirely using eBPF, reducing iptables complexity and improving observability.

Summary

Pods are temporary, and their IP addresses can change at any time.

Kubernetes Services provide a stable entry point, while kube-proxy makes the magic happen by programming networking rules on every node.

Understanding this flow helps you:

Debug Service connectivity issues faster
Choose the right Service type
Understand how traffic moves inside Kubernetes
Build more reliable Kubernetes applications

Next in the Series: CoreDNS Explained – How Kubernetes Turns Service Names into IP Addresses

Linux Process Management Explained Simply

Sreekanth Kuruba — Tue, 09 Jun 2026 03:02:49 +0000

Ever opened a Linux server and thought:

“Why is everything so slow or frozen?”

Most of the time, the problem is not Linux itself.

It’s running processes consuming resources in the background.

Let’s understand it simply.

What is a Process?

A process is a running program or service on your Linux system.

Examples:

Web browser
Web server (Nginx/Apache)
Database (MySQL, PostgreSQL)
Background services

What is PID?

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

PID = identity number of a running program

Example:

Chrome → PID 1234
Nginx → PID 5678

👉 You use PID to control processes (stop, monitor, debug).

1. Viewing Processes with `ps`

ps

Shows processes in current terminal only.

Better command:

ps aux

Shows ALL processes with:

CPU usage
Memory usage
User
PID
Command

👉 This is a daily DevOps debugging command.

Full system view:

ps -ef

Shows process hierarchy (parent → child relationships)

Difference:

Command         Use

ps aux          Resource monitoring (CPU/MEM)
ps -ef          Process structure view

2. Real-Time Monitoring `top`

top

top Shows live system activity:

You can see:

CPU usage
Memory usage
Running processes

Useful keys inside top:

q → Quit
k → Kill a process
M → Sort by memory usage
P → Sort by CPU usage

👉 Used when servers suddenly slow down or spike.

3. Better version: `htop`

# Install if not available:
sudo apt install htop     # Ubuntu/Debian
sudo dnf install htop     # Fedora/RHEL

Why devs prefer htop:

Colorful UI
Easier navigation
Process tree view
Simple killing of processes

👉 Much more user-friendly than top

4. Finding Specific Processes

ps aux | grep nginx
ps aux | grep python

Better alternatives:

pgrep nginx          # Returns only PIDs
pidof nginx          # Another way to get PID

👉 Faster way to get PID directly

5. Killing Processes

kill 1234            # Graceful kill
kill -9 1234         # Force kill (use only when necessary)

-> You must know the PID of the process to use kill.

Safer & easier ways:

pkill nginx          # Kill by process name
killall firefox      # Kill all processes with that name

⚠️ Always double-check PID before killing a process.

Wrong kill = system instability.

6. Background & Foreground Jobs

Foreground Process:

Runs in terminal and blocks it.

Background Process:

Runs without blocking terminal

Example:

sleep 100 &

& → sends process to background
You can continue using terminal

Useful commands:

jobs → Show background jobs
fg → Bring job to foreground
bg → Resume paused job in background

Useful when multitasking in terminal sessions.

7. Find Heavy Processes (CPU / Memory)

# Sort by CPU (highest first)
ps aux --sort=-%cpu | head

# Sort by Memory (highest first)
ps aux --sort=-%mem | head

👉 Very useful in production debugging.

⚠️ Important Safety Warning

Never kill critical system processes such as:

systemd
init
kernel processes (usually shown with square brackets)

👉 Doing so can crash your system completely.

Simple Mental Model

Think of Linux like a city:

Each app = a citizen
PID = ID card
CPU = energy usage
RAM = working space

Process management = controlling city traffic 🚦

Summary

In this guide you learned:

What a process is
What PID means
How programs run in Linux
Viewing processes (ps, top, htop)
Finding processes (grep, pgrep, pidof)
Killing processes safely (kill, pkill, killall)
Foreground vs background processes
Monitoring CPU and memory usage

why This Matters

Process management is used in:

DevOps debugging
Server monitoring
Performance optimization
Cloud environments
Production troubleshooting

👉 This is a core real-world Linux skill.

Next Post:
Linux Disk Usage Explained Simply, (df, du, mounting basics)

Question for You

Have you ever faced a server slowdown because of a single process?

I’ll show how to identify it instantly in Part 6.

Linux User & Group Management Explained Simply

Sreekanth Kuruba — Thu, 28 May 2026 12:42:16 +0000

Ever wondered how Linux knows:

who can access what, and what they are allowed to do?

That’s not random.

It’s controlled by users and groups — one of the most important concepts in Linux security and DevOps.

Let’s break it down simply.

What is a User in Linux?

A user is an account that interacts with the Linux system.

Every user has:

Username
User ID (UID)
Home directory
Default shell

Everything in Linux runs under a user identity.

Examples:

A developer user
A system admin user
A service user (like nginx)

What is a Group in Linux?

A group is a collection of users.

Think of it like a team:

Developers group → devs
QA group → testers
Admins group → system administrators

👉 Instead of assigning permissions one by one, you assign them to a group.

This makes Linux scalable and manageable.

Check Current User & Groups

whoami

Shows your current logged-in user.

id

Shows:

User ID (UID)
Group ID (GID)
All groups the user belongs to

groups

Shows all groups of the current user.

Creating a User

sudo useradd john

Creates a new user named john.

Note: This may not create a home directory in some systems.

Better way (recommended on Ubuntu/Debian):

sudo adduser john

👉 Automatically creates home directory + setup

Setting Password

sudo passwd john

Used to set or update user password.

Modifying Users (`usermod`)

sudo usermod -aG developers john

Adds user john to developers group.

Other examples:

sudo usermod -l newname oldname   # rename user
sudo usermod -d /new/home john    # change home directory

Deleting Users

sudo userdel john

Removes user only.

Remove user + home directory:

sudo userdel -r john

Managing Groups

Creating a Group

sudo groupadd developers

Deleting a Group

sudo groupdel developers

Important System Files

`/etc/passwd`

Stores user information:

username:x:UID:GID:comment:home:shell

Example:

john:x:1001:1001::/home/john:/bin/bash

👉 This file contains all users in the system.

`/etc/group`

Stores group information:

group_name:x:GID:user_list

Example:

developers:x:1002:john,mike

👉 Shows which users belong to which group.

What is sudo?

sudo allows a user to run commands as an administrator (root).

Example:

sudo apt update

Why sudo is important

Linux protects system files.

Normal users cannot modify system-level settings.

👉 sudo gives temporary admin power.

Important sudo concept

Not every user has sudo access
Only users in sudo or wheel group can use it

Check your groups:

groups

Real-World Example

In a company server:

Developers → normal users
Admins → sudo users
Services → system users (nginx, docker, etc.)

Each user has restricted access based on role

This keeps systems:

security
structure
control ⚙️

Why User & Group Management Matters

In DevOps and system administration:

You use this to:

control server access
manage teams on shared systems
secure applications
isolate services

Without it:

Linux systems become unmanageable and insecure

Summary

In this guide you learned:

What users are in Linux
What groups are
whoami, id, groups
useradd, adduser
usermod usage
userdel and cleanup
groupadd, groupdel
/etc/passwd structure
/etc/group structure
sudo basics
Real-world DevOps usage

Linux Process Management Explained Simply, (ps, top, htop, kill)

Question for You

Have you ever worked on a shared Linux server where multiple users caused confusion or permission issues?

I’ll show how real systems solve that in Part 5.

Linux File Permissions Explained Simply

Sreekanth Kuruba — Tue, 26 May 2026 12:13:26 +0000

Ever ran a Linux command and saw this?

Permission denied

It feels random at first — but it’s not.

That error is Linux protecting your system using file permissions.

Once you understand this, Linux security suddenly starts making sense.

What Are Linux File Permissions?

Every file and directory has three types of permissions:

Read (r) → View file content
Write (w) → Modify or delete file
Execute (x) → Run file as a program/script

👉 These decide what you are allowed to do with a file.

3 Types of Users in Linux

Permissions are not just for files — they are for users.

User Type	Symbol	Meaning
Owner	u	The owner of the file
Group	g	Users in the same group
Others	o	Everyone else

👉 Linux is a multi-user system, so access control is essential.

Understanding `ls -l` (Very Important)

Run this command:

ls -l

Example output:

-rwxr-xr-- 1 user group  1024 Apr 10 12:34 script.sh

Now it Breakdown:

First character → - = file, d = directory
Next 3 → Owner permissions
Next 3 → Group permissions
Last 3 → Others permissions

Permission Symbols

Symbol	Meaning
r	Read
w	Write
x	Execute
-	No permission

Changing Permissions `chmod`

Make script executable

chmod +x script.sh

Numeric method (very common in servers)

chmod 755 script.sh

Numeric permissions are a shortcut to set all three permission types at once.

Common Numeric Permissions:

Number	Permission	Meaning
7	rwx	Read + Write + Execute
6	rw-	Read + Write
5	r-x	Read + Execute
4	r--	Read only

👉 So:

755 = rwx r-x r-x

Owner → full access
Group → read + execute
Others → read + execute

Change Owner (`chown`)

chown username file.txt
chown user:group file.txt

Recursive:

chown -R user:group folder/

Only the root user or sudo user can change ownership.

Changing Group (`chgrp`)

chgrp developers project/

Used when:

multiple developers work on same project
shared access is needed

⚠️ Dangerous Mistake Beginners Make

chmod 777 file.txt     # ❌ Very Dangerous

🚨 This gives:

full access to everyone
no security control
breaks Linux permission model

👉 Never use this in real servers.

Real-Life Example

You create a script:

./script.sh

And get:

Permission denied

Fix:

chmod +x script.sh
./script.sh

👉 This is one of the most common Linux beginner issues.

Simple Mental Model

Think of Linux permissions like a building:

Owner → has master key
Group → shared access card
Others → guest access

And:

r → can look inside
w → can modify
x → can enter/run

Summary

You learned:

What r, w, x mean
User types (owner, group, others)
How to read ls -l
Using chmod
Numeric permissions (755, 644, etc.)
Changing ownership with chown
Changing groups with chgrp
Why chmod 777 is dangerous

Why This Matters

File permissions are not just theory.

They are used in:

Linux servers
DevOps pipelines
Docker containers
Cloud systems
Production deployments

👉 If you understand this, you understand Linux security basics.

Next Post:

Linux User & Group Management Explained Simply,useradd, usermod, groups

Which permission concept confused you the most when you first used Linux?

I’ll simplify it even further in Part 4.

Linux File System Explained Simply

Sreekanth Kuruba — Thu, 21 May 2026 09:53:57 +0000

Most beginners don’t struggle with Linux commands.

They struggle with one invisible problem:

They don’t understand how the Linux file system actually works.

Once this clicks, Linux stops feeling random — and starts feeling predictable.

Let’s fix that.

The Core Idea of Linux File System

Unlike Windows (C:, D: drives), Linux uses one single tree structure.

Everything starts from:

👉 This is called the root directory

Think of it as the “starting point of everything” in Linux.

All files, folders, devices, and even processes branch out from here.

Important Linux Mindset Shift

In Linux:

Everything is a file.

That includes:

Files 📄
Folders 📁
Hard disks 💽
USB devices 🔌
Processes ⚙️

This is why Linux feels different — but powerful.

Visualizing Linux Structure

Think of / like the trunk of a tree.

Everything grows from it:

/
├── home
├── etc
├── var
├── usr
├── bin
└── dev

Once you understand this tree, navigation becomes easy.

Paths in Linux (Very Important)

A path tells Linux where something is located.

🔹 Absolute Path

Starts from /

cd /home/user/documents

✔ Always full location
✔ Works from anywhere

🔹 Relative Path

Starts from where you are currently:

cd documents

✔ Shorter
✔ Depends on current location

Navigation Symbols

.   → current directory  
..  → parent directory

Example:

cd ..

👉 Go one step back

/home — Your Personal Space

/home/user

Each user gets a personal folder:

Documents
Downloads
Projects
Config files

👉 Think of it as your “workspace”

Important Linux Directories

Directory	Purpose	Common Usage
`/`	Root directory (starting point)	Everything is inside this
`/home`	User personal files	Documents, Downloads, Desktop
`/etc`	Configuration files	System & application settings
`/var`	Variable data (logs, caches, queues)	Logs, web server data
`/tmp`	Temporary files	Deleted on reboot
`/bin`	Essential binary commands	`ls`, `cp`, `mv`, `cat`
`/usr`	User installed programs & libraries	Most installed software
`/root`	Home directory of root (admin) user	Administrator files
`/boot`	Boot loader and kernel files	Files needed to start the system
`/dev`	Device files	Hard disks, USB, terminals
`/proc`	Process and system information	Live system data (virtual)
`/sys`	Kernel & hardware information	System hardware details
`/opt`	Optional software	Third-party applications
`/mnt` / `/media`	Mount points for external drives	USB drives, additional disks

Detailed Explanation of Most Used Directories

1./home — Your workspace

Where your projects, downloads, and personal files live.

2./etc — System control center

Contains almost all configuration files.
This is one of the most critical directories in Linux systems.

/etc/passwd — user accounts
/etc/ssh/sshd_config — SSH settings
/etc/nginx/ — web server config

👉 If Linux had a “settings app”, this is it.

3./var — Changing data (VERY important)

Used for data that keeps changing:
Most production issues can be traced by checking logs in /var/log.

/var/log/ — system and application logs
/var/www/ — Default web files (for Apache/Nginx)

4./tmp — Temporary space

Used for temporary files.
Usually cleared on reboot

⚠️ Never store important data here.

5./usr — Installed software

Main location for installed user programs and libraries.

Examples:

/usr/bin/ — most user commands

Most system commands come from here.

6./boot — Startup system

Contains kernel and boot files.

⚠️ If broken → system may not boot.

7./dev — Hardware as files

Represents hardware devices as files.

Examples:

/dev/sda → hard disk
/dev/tty → terminals

Everything in Linux is treated as a file, including hardware.

8./proc — Live system data

Virtual filesystem showing:

processes
memory
CPU info

👉 It’s not stored on disk — it’s generated live.

9./root — Admin home

Not the same as /

/ → whole system
/root → admin user’s home

10./mnt & /media — External drives

Used when you plug:

USB
external HDD
extra disks

What is Mounting? (Important Concept)

In Linux, storage devices don’t automatically appear like in Windows.

Instead, they are “attached” to a folder.

This process is called mounting.

Example:

USB drive → mounted to /media
Extra disk → mounted to /mnt
System disk → mounted to /

Useful Commands to Explore the Filesystem

pwd → Show current location
ls/ → List root directories
cd /var/log
tree → Visual directory structure

Simple Mental Model

Think of Linux filesystem like this:

/ = The whole computer
/home = My personal room
/etc = Settings room
/var = Logs & changing data
/tmp = Temporary workspace
/usr = Installed applications
/boot = Engine to start the system

👉 Once this clicks, Linux becomes predictable.

⚠️ Common Beginner Mistakes

Storing important files in /tmp
Editing files in /etc without backup
Deleting unknown system folders
Running this blindly:

Running `rm -rf /`

⚠️ Never do this.

Summary

You learned:

Linux starts from /
Everything is a file
Absolute vs relative paths
Navigation symbols . and ..
Important system directories:
/home → User files
/etc → Configuration files
/var → Logs and variable data
/tmp → Temporary files
/usr → Installed software
/boot → Boot files
/dev → Hardware devices

Why This Matters

If you understand the Linux file system:

Commands become easier
Debugging becomes faster
Servers stop feeling confusing
DevOps becomes logical instead of random

Next Post:
Linux File Permissions Explained Simply (chmod, chown, chgrp)

Question for You

Which Linux directory confused you the most when you started?

I’ll simplify it in Part 3.

10 Essential Linux Commands Every Beginner Must Know

Sreekanth Kuruba — Tue, 19 May 2026 03:24:57 +0000

Most beginners don’t struggle with Linux because it’s hard.

They struggle because they try to learn everything at once.

The truth is simple:

You only need a small set of commands to start working confidently in Linux, DevOps, and cloud environments.

In this post, you’ll learn 10 essential Linux commands that are used every day on real servers.

If you understand these, Linux will finally start to “click”.

What You’ll Learn in 5 Minutes

By the end of this post, you will know how to:

Navigate files and folders
Create, copy, move, and delete files
View file contents
Understand basic system interaction

These are the exact commands used in real DevOps workflows.

Before We Start (Important Mindset Shift)

Think of Linux like your smartphone.

Android/iOS → Linux OS
Apps → Programs
Settings → System configuration
Storage → Linux folders
Permissions popup → File permissions
Restart phone → System reboot

You don’t “see” the system — you just use it.

That’s exactly how Linux works.

1. `ls` — List Files and Directories

ls
ls -l     # Detailed list (permissions, size, date)
ls -a     # Show hidden files
ls -la    # Most commonly used combination

Real-world usage:
Used daily to check files, permissions, and directory contents.

2. `cd` — Change Directory

cd /home/user/documents
cd ..     # Go back one directory
cd ~      # Go to home directory
cd -      # Go to previous directory

Real-world usage:
Used to navigate between directories in servers and systems.

3. `pwd` — Print Working Directory

pwd

Shows your current location in the filesystem.

Real-world usage:
Used to verify current working path.

4. `mkdir` — Make Directory

mkdir myfolder
mkdir -p dir1/dir2/dir3   # Create nested directories

Real-world usage:
Used to create project folders or directory structures.

5. `rm` — Remove Files or Directories

⚠️ Dangerous command — can delete everything permanently if misused.

rm file.txt
rm -r foldername          # Remove directory
rm -rf foldername         # Force remove (very dangerous)
rmdir foldername          # To remove only an empty directory

Safer alternative with confirmation:

rm -ri foldername

-i asks before deleting each file.

Tip: Always use ls first before deleting anything.
Tip: In Linux, there is no recycle bin in most servers. Deleted files are usually gone permanently.

Real-world usage:
Used to delete unwanted files or clean up space.

6. `cp` — Copy Files and Directories

cp file.txt file_backup.txt
cp -r folder1 folder2     # Copy folder

Real-world usage:
Used for backups before modifying files.

7. `mv` — Move or Rename Files

mv file.txt /home/user/docs/
mv oldname.txt newname.txt   # Rename file

Real-world usage:
Used to move logs, configs, or rename files.

8. `cat` — View File Content

cat filename.txt

Real-world usage:
Used to quickly view file contents like logs and configuration files.

9. `touch` — Create Empty File

touch newfile.txt

Real-world usage:
Used to create log or config files.

10. `echo` — Print Text / Write to File

echo "Hello World"
echo "Hello Linux" > file.txt     # Create/overwrite file
echo "New line" >> file.txt       # Append to file

Real-world usage:
Used to write data into files or test outputs.

Beginner Basics (Highly Recommended)

What is a Terminal?

The terminal is a text-based interface used to interact with the Linux operating system using commands.

Basic Command Structure

Most Linux commands follow this format:

command [options] [arguments]

Example

ls -la /home/user

ls → command
-la → options
/home/user → argument

Linux is Case-Sensitive

Linux treats uppercase and lowercase differently.

file.txt
FILE.txt

These are considered two different files.

Paths in Linux

Absolute Path

Starts from the root directory.

cd /home/user/documents

Relative Path

Starts from your current location.

cd documents

Useful Beginner Commands

man ls       # Show manual for any command
ls --help   # Quick help
whoami       # Show current logged-in user
id           # Shows user and group IDs
uname -a    # Display system information
history      # Show previously used commands

Keyboard Shortcuts Every Beginner Should Know

Ctrl + C     # Stop a running command
Ctrl + Z     # Pause/suspend a running process

Bonus: sudo — Run Commands as Administrator

sudo apt update
sudo mkdir /newfolder
sudo chown user:group file.txt

sudo stands for “SuperUser DO” and runs commands with admin (root) privileges.
Gives you temporary admin rights
You will use it very often for installing packages and editing system files

Warning: Use sudo only when necessary.

Why These Commands Matter

These commands form the foundation of working with Linux.

Almost every advanced Linux task — DevOps, cloud computing, scripting, server management — builds on these basics.

Summary

You learned:

Navigation → ls, cd, pwd
File Management → mkdir, cp, mv, rm, touch
File Content → cat, echo
Administrator access → sudo
System & User Info -> whoami, id, uname -a, history

Next Steps:

After mastering these basics, next learn:
Linux File System Explained Simply,(/, /home, /etc, /var, etc.)

DEV Community: Sreekanth Kuruba

How CoreDNS Powers Service Discovery in Kubernetes

Why Do We Need DNS in Kubernetes?

What Is CoreDNS?

Where Does CoreDNS Run?

How Service Discovery Works

Kubernetes DNS Naming

DNS Lookup Flow

Important DNS Records

ClusterIP Service

Headless Service

Common DNS Problems and Solutions

1. Service name not resolving?

2. Test DNS from a Pod

3. Check CoreDNS Pods

4. View CoreDNS Logs

Why CoreDNS Matters

Summary

Linux Networking Basics for Beginners

Basic Networking Concepts (Must Know First)

1. Check Internet Connectivity with ping

2. Test Web Requests with curl

3. Check DNS Resolution

4. Check Your IP Address

5. Check Routing path

6. Check Open Ports

7. Trace Network Path with traceroute

8. Enhanced Traceroute with mtr

Simple Troubleshooting Flow (VERY IMPORTANT)

⚠️ Common Beginner Mistakes

Summary

Real production lesson: Logs can fill a server faster than applications. Always monitor /var/log growth before it becomes an outage. #sre #devops

Real production lesson: Logs can fill a server faster than applications. Always monitor /var/log growth before it becomes an outage. #sre #devops

SSH Sessions Dropping Frequently? Here's Exactly How I Troubleshoot It

1. Check Network Connectivity First

2. Check Server Resource Usage

3. Check SSH Logs

Ubuntu/Debian

RHEL/CentOS/Rocky

Modern systems

4. Fix SSH Timeout Settings (Server Side)

5. Configure Client-Side Keepalive

6. Check Firewalls, VPNs & Load Balancers

7. Use tmux or screen (A Life Saver)

8. Check System Limits

Bonus Tip: Enable SSH Debugging

A Real Production Incident

My SSH Troubleshooting Flow

Final Thoughts

Linux Disk Usage Explained Simply

Disk Usage Basics (You Must Know This First)

What is a Filesystem?

File Size vs Disk Usage

What is Mounting?

1. Check Overall Disk Usage with df

2. Check Folder and Directory Size with du

3. Find Large Files in the System

4. Find Biggest Directories (Very Important)

5. Disk Full but Space Looks Free? (INODES)

6. Deleted Files Still Using Space

Bonus Tool: ncdu (Best for Beginners)

⚠️ Common Beginner mistakes

Summary

How Does Traffic Actually Reach Your Pods? Kubernetes Services & kube-proxy Explained

What is a Kubernetes Service?

How Does a Service Find Its Pods?

Why Do We Need Services?

Types of Kubernetes Services

1. ClusterIP (Default)

2. NodePort

3. LoadBalancer

4. ExternalName

How Services Work Under the Hood

kube-proxy: The Unsung Hero

iptables Mode

IPVS Mode

Userspace Mode

Traffic Flow Example

Common Service Problems

Pods are not receiving traffic?

1. Check Internet Connectivity with `ping`

2. Test Web Requests with `curl`

7. Trace Network Path with `traceroute`

8. Enhanced Traceroute with `mtr`

7. Use `tmux` or `screen` (A Life Saver)

1. Check Overall Disk Usage with `df`

2. Check Folder and Directory Size with `du`

Bonus Tool: `ncdu` (Best for Beginners)

1. Viewing Processes with `ps`

2. Real-Time Monitoring `top`

3. Better version: `htop`

Modifying Users (`usermod`)

`/etc/passwd`

`/etc/group`

Understanding `ls -l` (Very Important)

Changing Permissions `chmod`

Change Owner (`chown`)

Changing Group (`chgrp`)

1. `ls` — List Files and Directories

2. `cd` — Change Directory

3. `pwd` — Print Working Directory

4. `mkdir` — Make Directory

5. `rm` — Remove Files or Directories

6. `cp` — Copy Files and Directories

7. `mv` — Move or Rename Files

8. `cat` — View File Content

9. `touch` — Create Empty File

10. `echo` — Print Text / Write to File