DEV Community: Alkesh Baghel

Concept Of Ingress In Kubernetes : Basics

Alkesh Baghel — Fri, 02 May 2025 07:06:57 +0000

🌀 What is Ingress in Kubernetes?

Hey! So today, let’s talk about Ingress in Kubernetes. If you’re working with Kubernetes and wondering how the outside world can access your apps inside the cluster, Ingress is your answer.

💡 In Simple Words...

Ingress is like the front door to your Kubernetes cluster for web traffic (HTTP and HTTPS). It knows where to send incoming requests based on rules you define. Think of it like a traffic controller at a mall entrance, telling visitors which shop to go to.

🛠️ A Real YAML Example of Ingress

Let’s break down a real Ingress configuration that uses the NGINX Ingress Controller:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: minimal-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx-example
  rules:
  - http:
      paths:
      - path: /testpath
        pathType: Prefix
        backend:
          service:
            name: test
            port:
              number: 80

🔍 What’s Happening Here?

Annotations: Rewrite any request to /testpath to / before sending to the backend.
ingressClassName: Tells Kubernetes which Ingress Controller to use (in this case, nginx-example).
rules: Says, "If someone hits /testpath, forward the request to the test service on port 80."

🧭 What is `pathType` and Why It Matters?

Each path in an Ingress rule must have a pathType. It tells Kubernetes how to match the request path.

🧩 Supported `pathType` values:

Prefix – Matches if the request path starts with the given path.
Exact – Matches only if the request path is exactly the same.
ImplementationSpecific – Behavior depends on the Ingress Controller you're using.

➕ Multiple Matches – Who Wins?

If more than one rule matches a request, Kubernetes uses the following logic:

Longest matching path wins.
If paths are the same length, Exact wins over Prefix.

🔄 Types of Ingress

There are three common types of Ingress setups:

1. Path-Based Routing (Rule-Based Routing)

This is the most common type. You route requests based on the URL path.

➡️ Already covered in the minimal-ingress YAML.

2. Default Backend Ingress

This type doesn't define any specific rules. It acts as a catch-all. If no rule matches, it sends traffic to a default service.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
spec:
  defaultBackend:
    service:
      name: test
      port:
        number: 80

Think of it like: "If a request doesn’t match any rule, just send it to the test service."

3. Host-Based Routing (Name-Based Routing)

This lets you route traffic based on the domain name used in the request. For example:

foo.example.com → goes to one service
bar.example.com → goes to another service

Here’s an example:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: host-based-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: foo.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: foo-service
            port:
              number: 80
  - host: bar.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: bar-service
            port:
              number: 80

🧠 Use case: You have multiple websites or apps with different domain names hosted on the same Kubernetes cluster. This Ingress allows each one to route correctly.

🧪 Deploy and View the Ingress

Apply the Ingress YAML using:

kubectl apply -f your-ingress.yaml

To view the Ingress resource:

kubectl get ingress

Example output:

NAME                CLASS    HOSTS                   ADDRESS          PORTS   AGE
host-based-ingress  nginx    foo.example.com,...     a1b2.elb...com   80      2m

Note: It may take a minute or two for AWS to assign an IP address or DNS to your Ingress. Until then, the address may show as <pending>.

📦 Final Thoughts

Ingress is your smart HTTP/HTTPS gateway into the cluster.
You can configure routing:
- Based on path (e.g., /test)
- Based on host (e.g., foo.example.com)
- Or fallback to a default backend
Always define a pathType.
Use kubectl get ingress to check its status.
Give it a moment to get an IP—it's normal to see <pending> at first.

🐧 Linux Basics – Part 6: Understanding File Permissions

Alkesh Baghel — Fri, 25 Apr 2025 04:55:54 +0000

Let’s roll right into Part 6! This one is all about file permissions—a topic that might look confusing at first, but don’t worry, we’ll break it down super simply. 😎

Hey friends! 👋

Welcome back to our Linux series. By now, you've mastered file navigation, management, and even editing files in the terminal. 💻✨

Today, we’re tackling something you must know as a Linux user: file permissions.

If you’ve ever seen something like this:

-rw-r--r-- 1 tejaswini tejaswini  120 Apr 25 10:35 hello.txt

…and thought, “Uh, what is all that supposed to mean?”—you’re in the right place. Let’s decode it. 🕵️‍♀️

🔐 What Are File Permissions?

File permissions determine who can read, write, or execute a file or folder.

There are 3 types of permissions:

r – read
w – write
x – execute

And these apply to 3 groups:

User – the owner of the file
Group – users in the same group as the owner
Others – everyone else

So rw-r--r-- breaks down like this:

[ rw- ]  [ r-- ]  [ r-- ]
   ↑        ↑        ↑
 User     Group     Others

User can read + write
Group can read only
Others can read only

👀 Check Permissions – `ls -l`

Use ls -l to see file details, including permissions.

Example:

ls -l hello.txt

Output:

-rw-r--r-- 1 tejaswini tejaswini  120 Apr 25 10:35 hello.txt

Here’s how to read it:

-: it’s a file (d would mean a directory)
rw-: owner can read/write
r--: group can only read
r--: others can only read

✏️ Change Permissions – `chmod`

Use chmod (change mode) to modify permissions.

Examples:

Give everyone execute permission:

chmod +x script.sh

Remove write access for group and others:

chmod go-w file.txt

Set permissions exactly (e.g. 755):

chmod 755 myscript.sh

Quick number breakdown:

7 = read (4) + write (2) + execute (1)
6 = read + write
5 = read + execute
4 = read only
0 = no permission

So chmod 755 means:

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

👑 Change Owner – `chown`

Sometimes, you’ll need to change who owns a file.

Example:

sudo chown newuser:newgroup file.txt

This gives ownership to newuser and assigns it to newgroup.

🧪 Try It Yourself

Create a file called test.sh.
Give it execute permissions.
Check the permission before and after.

touch test.sh
ls -l test.sh
chmod +x test.sh
ls -l test.sh

You’ll see that -rw-r--r-- becomes -rwxr-xr-x.

🧭 Quick Reference Table

Task	Command
View file permissions	`ls -l`
Add permission	`chmod +x file`
Remove permission	`chmod g-w file`
Set numeric permissions	`chmod 755 file`
Change file owner	`sudo chown user:group file`

⚠️ Be Cautious

Changing permissions can affect security. Be especially careful with:

chmod 777 – gives everyone full access (use only when absolutely needed)
Scripts with chmod +x – only do this for trusted files

🔚 Wrapping Up

Congrats! 🎉 You just unlocked a powerful part of Linux. File permissions might look intimidating at first, but once you understand the logic behind them, they’re super manageable—and crucial for keeping your system safe and organized.

In Part 7, we’ll explore Linux processes—how to view running programs, stop them, and monitor system activity using commands like ps, top, and kill.

Stay curious, keep playing with commands, and you’ll be a terminal wizard in no time. 🧙‍♀️

🐧 Linux Basics – Part 5: Viewing and Editing Files from the Terminal

Alkesh Baghel — Fri, 25 Apr 2025 04:50:22 +0000

Hey there! 👋

Welcome back to our Linux series! So far, you’ve learned how to move around the filesystem, manage files and folders, and probably started feeling like a terminal pro. 🔥

Now it’s time to learn how to view and edit file content directly from the command line.

This is super handy when you’re working on servers, writing scripts, or just don’t want to open a full-blown text editor.

Let’s break it down with the most commonly used commands. 👇

👁️ View File Content – `cat`

The cat command is the quickest way to display the contents of a file.

Example:

cat hello.txt

It will print everything inside hello.txt right there in your terminal.

💡 Tip: Best for small files. It can get messy if the file is too long.

🧵 View One Page at a Time – `less`

For bigger files, use less. It lets you scroll and search too!

Example:

less bigfile.txt

Use the arrow keys to scroll, q to quit.

🧠 Fun fact: You can search inside less by typing /word and hitting Enter.

🔍 See the Beginning – `head`

Want to quickly peek at the first few lines?

Example:

head hello.txt

By default, it shows the first 10 lines. Want more?

head -n 20 hello.txt

🔚 See the End – `tail`

As the name suggests, tail shows the end of a file.

Example:

tail hello.txt

Also shows 10 lines by default. Want to see the last 5?

tail -n 5 hello.txt

Bonus: You can even watch a file in real time (great for logs):

tail -f server.log

✍️ Editing Files – `nano` (Beginner-Friendly Editor)

Ready to make some changes? nano is a simple text editor that works right in the terminal.

Example:

nano notes.txt

You’ll be taken into an interactive editor. Use arrow keys to move around, make your edits, and when you’re done:

Press Ctrl + O to save
Press Enter to confirm filename
Press Ctrl + X to exit

🧠 Compared to Windows: Think of it like a very minimal Notepad, but in the terminal.

🧪 Mini Challenge

Try this mini project to get hands-on:

Create a file named quote.txt.
Add your favorite quote using nano.
View it using cat.
Check the first line using head -n 1.
Check the last line using tail -n 1.

Commands:

touch quote.txt
nano quote.txt
cat quote.txt
head -n 1 quote.txt
tail -n 1 quote.txt

Easy and useful!

🧭 Quick Reference

Task	Command
View full file	`cat filename`
View paged content	`less filename`
View top lines	`head filename`
View bottom lines	`tail filename`
Watch file in real-time	`tail -f filename`
Edit a file	`nano filename`

🔚 Wrapping Up

And that’s a wrap for Part 5! 🥳

Being able to quickly view and edit files from the terminal is a superpower, especially when working on remote systems or debugging scripts.

Next up in Part 6, we’ll dive into file permissions—what drwxr-xr-x means, how to use chmod, chown, and how to control who can do what with your files.

Stay curious, keep experimenting, and feel free to drop questions if anything feels confusing. You're doing great! 💪

🐧 Linux Basics – Part 4: Creating, Moving, and Deleting Files and Folders

Alkesh Baghel — Fri, 25 Apr 2025 04:44:09 +0000

Awesome! Here's Part 4 of your Linux series, written in the same natural, engaging, beginner-friendly tone:

🐧 Linux Basics – Part 4: Creating, Moving, and Deleting Files and Folders

Hey hey! 👋

Welcome back to our Linux command line series. If you've been following along, you’re already comfy moving around the filesystem like a champ. Now it’s time to level up with something every user needs to know: how to manage files and folders using simple commands.

In this part, we’ll cover how to create, rename, move, copy, and delete files and directories—all from the terminal. Yep, no mouse-clicking needed! 😄

Let’s get straight to it!

📝 Creating Files – `touch`

Want to create an empty file? Easy. Use touch.

Example:

touch hello.txt

This instantly creates an empty file called hello.txt in your current directory.

💡 Windows comparison: Like right-click → New → Text Document.

📁 Creating Directories – `mkdir`

Want to make a new folder? Use mkdir (short for make directory).

Example:

mkdir myfolder

Want to create a folder and a subfolder in one go?

mkdir -p projects/python

The -p flag tells Linux to create parent folders if they don't exist.

✂️ Moving and Renaming – `mv`

The mv command works for both moving and renaming files and directories.

Rename a file:

mv hello.txt greetings.txt

Move a file into a folder:

mv greetings.txt myfolder/

🧠 Pro tip: You can move multiple files at once:

mv file1.txt file2.txt myfolder/

📄 Copying Files – `cp`

Want to duplicate a file? Use cp.

Example:

cp hello.txt backup.txt

To copy a file into a folder:

cp hello.txt myfolder/

To copy an entire folder and its contents:

cp -r myfolder newfolder

The -r stands for recursive, which is required when copying directories.

🗑️ Deleting Files and Folders – `rm`

Use rm (remove) to delete stuff. Be careful—there’s no “Recycle Bin” here!

Delete a file:

rm hello.txt

Delete a folder and all its contents:

rm -r myfolder

⚠️ Use this command carefully—especially with -r!

🧪 Try This!

Here's a mini practice session:

Create a folder named testlab.
Inside testlab, create two files: one.txt and two.txt.
Rename one.txt to first.txt.
Copy first.txt into a folder called backup.
Delete two.txt.

Commands you'd use:

mkdir testlab
cd testlab
touch one.txt two.txt
mv one.txt first.txt
mkdir backup
cp first.txt backup/
rm two.txt

Boom 💥—you just did file management like a Linux ninja.

🧭 Quick Reference Table

Task	Command
Create file	`touch filename.txt`
Create folder	`mkdir foldername`
Rename file/folder	`mv oldname newname`
Move file/folder	`mv item destination/`
Copy file	`cp file destination/`
Copy folder	`cp -r folder newfolder`
Delete file	`rm filename.txt`
Delete folder	`rm -r foldername`

🔚 Wrapping Up

That’s a wrap on file and folder management in Linux! 🎉

These are essential commands you’ll use all the time. Practice them a bit and you’ll find yourself zipping through file tasks without ever needing a GUI.

Next up in Part 5, we’ll take a look at viewing and editing file content—using commands like cat, less, head, tail, and even simple editors like nano.

Stay tuned, and keep exploring! 🚀

🐧 Linux Basics – Part 3: Navigating the Filesystem Like a Pro

Alkesh Baghel — Fri, 25 Apr 2025 04:40:16 +0000

Hey folks! 👋

Welcome back to our Linux command line series. If you've been following along, you've already dipped your toes into the terminal and started getting comfortable with basic commands. In this third part, we're stepping into one of the core skills every Linux user needs—navigating the filesystem.

Understanding how to move around your directories, find files, and list contents is key to becoming comfortable in the Linux environment. So, let's jump right into it—with simple examples and some Windows comparisons to keep things relatable. 😄

🔍 Where am I? (`pwd`)

The first thing you’ll often want to know in a terminal session is: Where exactly am I right now?

That’s where pwd comes in. It stands for Print Working Directory.

Example:

pwd

Output:

/home/user/Documents

This tells you that you're currently inside the Documents folder, which is under your home directory. Think of it like looking at the address bar in Windows Explorer.

📁 Seeing What's Around (`ls`)

The ls command is your go-to for listing the contents of any directory.

Example:

ls

Output:

project1  notes.txt  screenshots  music.mp3

This shows everything inside your current directory. It's like opening a folder in Windows and seeing all the files and subfolders.

Useful Flags:

ls -l: Shows detailed information (like file size, permissions, and timestamps).
ls -a: Lists hidden files too (those that start with a .).
ls -lh: Combines it all with human-readable file sizes.

🚶‍♀️ Moving Around (`cd`)

Now let’s say you want to go from your current folder into a subfolder called project1.

Example:

cd project1

To go back one step:

cd ..

To go to your home directory (from anywhere):

cd ~

To go to the root directory:

cd /

Windows comparison: This is like double-clicking folders in Windows File Explorer or clicking the "Back" button.

🧭 A Quick Recap of Navigation

Task	Linux Command	Windows Equivalent
Show current folder	`pwd`	Address bar in File Explorer
List files in folder	`ls`	Opening a folder
Move into a folder	`cd foldername`	Double-clicking a folder
Go back one folder	`cd ..`	Clicking the back arrow
Go to home directory	`cd ~`	`C:\Users\YourName`

💡 Bonus Tip: Tab Completion

When typing long folder or file names, you can hit the Tab key and Linux will try to auto-complete it for you. It saves time and avoids typos!

🧪 Practice Time

Try these steps:

Open your terminal.
Run pwd to see where you are.
Use ls to see what’s in your current folder.
Move into a folder using cd.
Come back using cd ...

Exploring this way builds muscle memory and helps you become fluent with the Linux terminal.

🔚 Wrapping Up

That’s it for this part! Now you know how to navigate like a pro. In the next post, we’ll dive into file and directory management—creating, moving, copying, and deleting files from the command line. 🛠️

If you’re enjoying this series, don’t forget to bookmark it or share it with someone who's just getting started with Linux. And feel free to drop your questions or suggestions for future topics—we’re building this series together! 😊

🐧 Linux Basics Part 2: File Operations, Viewing Content & Permissions

Alkesh Baghel — Thu, 24 Apr 2025 11:58:13 +0000

Welcome back to our Linux beginner series! In this part, we’ll explore how to work with files, read their contents, and understand Linux file permissions. Let’s dive right in!

📁 1. File Operations

➕ Create a File: `touch`

touch file.txt

Creates an empty file named file.txt.

📝 Edit a File (Using `nano`)

nano file.txt

Opens a simple text editor in the terminal.
Save with CTRL + O, then press Enter.
Exit with CTRL + X.

🗑️ Delete a File: `rm`

rm file.txt

Deletes the specified file.
⚠️ Be careful! There's no recycle bin.

📝 Copy a File: `cp`

cp file1.txt file2.txt

Copies file1.txt to file2.txt.

🔁 Move or Rename a File: `mv`

mv oldname.txt newname.txt

Renames oldname.txt to newname.txt.
You can also move it to another folder.

📖 2. Viewing File Content

📄 `cat` – Show file content

cat file.txt

Displays the whole file in the terminal.

🔍 `less` – View large files

less bigfile.txt

Allows scrolling through the file.
Use q to quit.

🧠 `head` and `tail` – View start/end of a file

head file.txt
tail file.txt

head shows the first 10 lines, tail shows the last 10.
Add -n to specify number of lines:

  tail -n 20 file.txt

🔐 3. File Permissions

Every file and folder has permissions that control who can read, write, or execute them.

➤ See Permissions: `ls -l`

ls -l

You’ll see something like:

-rw-r--r-- 1 user group  123 Apr 24 08:00 file.txt

Let’s break it down:

-rw-r--r-- = permissions
- r = read
- w = write
- x = execute
First set is for owner, second for group, third for others.

🛠️ Change Permissions: `chmod`

chmod +x script.sh

Makes script.sh executable.

👤 Change Ownership: `chown`

sudo chown tejaswini file.txt

Changes the file’s owner to tejaswini.

🔁 Comparison with Windows

Task	Linux Command	Windows Equivalent
View file	`cat`, `less`	Notepad, `type`
Create file	`touch`	Right-click → New → Text file
Change perm	`chmod`	File properties → Security

🎯 Practice Tips:

Try making a text file, adding some text with nano, and viewing it with cat and less.
Experiment with changing permissions and making a script executable.

Next up in Part 3, we’ll explore process management, network commands, and a bit of package management! Stay tuned.

🔥 Beginner’s Guide to Linux: Why Linux & Basic Commands You Should Know (Part 1)

Alkesh Baghel — Thu, 24 Apr 2025 07:38:45 +0000

if you’ve ever wondered why developers, system admins, and tech enthusiasts rave about Linux, you’re not alone. In this series, we’ll explore Linux from the ground up—starting with why it’s used, its benefits, and some basic but powerful commands every beginner should know.

🐧 What is Linux?
Linux is an open-source operating system—that means it’s free to use, modify, and distribute. It powers everything from smartphones (Android is Linux-based) to supercomputers, servers, and even space missions!

📜** A Quick History**

Linux was created in 1991 by Linus Torvalds as a hobby project.
He wanted to build a free alternative to the UNIX operating system.
The community loved it, contributed to it, and now Linux is everywhere!

💻 Why Linux Over Windows?

Free and Open Source – No license fees or restrictions.
Customizable – You can tweak every part of the OS.
Stable and Secure – Fewer viruses and system crashes.
Lightweight – Runs even on older hardware.
Developer-Friendly – Most programming and DevOps tools run natively on
Linux.
Command Line Power – More control through terminal commands.

Windows is great for personal use and UI-focused tasks, but when it comes to servers, automation, or development work—Linux shines.

🧱 Linux Distributions
There’s no single “Linux OS”—there are many distributions (or distros) based on Linux:

Ubuntu – Great for beginners, very user-friendly.
Debian – Stable and reliable.
CentOS / Rocky Linux – Often used on servers.
Arch Linux – Customizable, for advanced users.
Kali Linux – Used for penetration testing and cybersecurity.

Choose one based on your needs. For beginners, Ubuntu is a great starting point.

Don’t worry if these look unfamiliar—we’ll go through each one step by step in the next parts of this series.

📌 Coming Up Next
In the next post, we’ll dive into using these commands with real-world examples and practice tasks. You’ll be navigating Linux like a pro in no time!

LinuxForBeginners #LinuxCommands #Ubuntu #OpenSource #DevOps #SysAdmin #TechLearning #TerminalCommands #WhyLinux #LinuxVsWindows #LinuxBasics #ShellCommands #CommunityLearning #LearnLinux

DEV Community: Alkesh Baghel

Concept Of Ingress In Kubernetes : Basics

🌀 What is Ingress in Kubernetes?

💡 In Simple Words...

🛠️ A Real YAML Example of Ingress

🔍 What’s Happening Here?

🧭 What is pathType and Why It Matters?

🧩 Supported pathType values:

➕ Multiple Matches – Who Wins?

🔄 Types of Ingress

1. Path-Based Routing (Rule-Based Routing)

2. Default Backend Ingress

3. Host-Based Routing (Name-Based Routing)

🧪 Deploy and View the Ingress

📦 Final Thoughts

🐧 Linux Basics – Part 6: Understanding File Permissions

🔐 What Are File Permissions?

👀 Check Permissions – ls -l

Example:

Output:

✏️ Change Permissions – chmod

Examples:

Quick number breakdown:

👑 Change Owner – chown

Example:

🧪 Try It Yourself

🧭 Quick Reference Table

⚠️ Be Cautious

🔚** Wrapping Up**

🐧 Linux Basics – Part 5: Viewing and Editing Files from the Terminal

👁️ View File Content – cat

Example:

🧵 View One Page at a Time – less

Example:

🔍 See the Beginning – head

Example:

🔚 See the End – tail

Example:

✍️ Editing Files – nano (Beginner-Friendly Editor)

Example:

🧪** Mini Challenge**

🧭 Quick Reference

🔚 Wrapping Up

🐧 Linux Basics – Part 4: Creating, Moving, and Deleting Files and Folders

🐧 Linux Basics – Part 4: Creating, Moving, and Deleting Files and Folders

📝 Creating Files – touch

Example:

📁 Creating Directories – mkdir

Example:

✂️ Moving and Renaming – mv

Rename a file:

Move a file into a folder:

📄 Copying Files – cp

Example:

🗑️ Deleting Files and Folders – rm

Delete a file:

Delete a folder and all its contents:

🧪** Try This!**

🧭 Quick Reference Table

🔚 Wrapping Up

🐧 Linux Basics – Part 3: Navigating the Filesystem Like a Pro

🔍 Where am I? (pwd)

Example:

Output:

📁 Seeing What's Around (ls)

Example:

Output:

Useful Flags:

🚶‍♀️ Moving Around (cd)

Example:

🧭 A Quick Recap of Navigation

💡 Bonus Tip: Tab Completion

🧪** Practice Time**

🔚 Wrapping Up

🐧 Linux Basics Part 2: File Operations, Viewing Content & Permissions

📁 1. File Operations

➕ Create a File: touch

📝 Edit a File (Using nano)

🗑️ Delete a File: rm

📝 Copy a File: cp

🧭 What is `pathType` and Why It Matters?

🧩 Supported `pathType` values:

👀 Check Permissions – `ls -l`

✏️ Change Permissions – `chmod`

👑 Change Owner – `chown`

🔚 Wrapping Up

👁️ View File Content – `cat`

🧵 View One Page at a Time – `less`

🔍 See the Beginning – `head`

🔚 See the End – `tail`

✍️ Editing Files – `nano` (Beginner-Friendly Editor)

🧪 Mini Challenge

📝 Creating Files – `touch`

📁 Creating Directories – `mkdir`

✂️ Moving and Renaming – `mv`

📄 Copying Files – `cp`

🗑️ Deleting Files and Folders – `rm`

🧪 Try This!

🔍 Where am I? (`pwd`)

📁 Seeing What's Around (`ls`)

🚶‍♀️ Moving Around (`cd`)

🧪 Practice Time

➕ Create a File: `touch`

📝 Edit a File (Using `nano`)

🗑️ Delete a File: `rm`

📝 Copy a File: `cp`

🔁 Move or Rename a File: `mv`

📄 `cat` – Show file content

🔍 `less` – View large files

🧠 `head` and `tail` – View start/end of a file

➤ See Permissions: `ls -l`

🛠️ Change Permissions: `chmod`

👤 Change Ownership: `chown`