DEV Community: Jabulani Meki

How I Installed Kali Linux with Enterprise-Level LVM as a Beginner

Jabulani Meki — Mon, 02 Jun 2025 01:19:12 +0000

Why I Did This

I wanted to truly learn Linux not just use it. So I decided to:

Erase Windows from my machine
Download different distros
Learn the hard stuff, the real sysadmin stuff

One of the most confusing things when I started? LVM (Logical Volume Management). Everyone said, “you don’t need to use it.” But I thought:

If real companies use it, why shouldn’t I learn it now?

So I did. And in this post, I’ll show you how I manually installed Kali Linux with a realistic, enterprise-style LVM layout using just the Graphical Installer.

My Setup

OS: Kali Linux
Disk: 50GB (virtual machine)
Install mode: Manual partitioning (Graphical Installer)
Objective: Simulate a company-style layout with LVM

Partition Plan

I wanted my partitions to reflect what a real sysadmin might do:

Disk Partitions

Partition	Size	Mount Point	Type
/boot	1 GB	/boot	ext4 (non-LVM)
LVM PV	~48 GB	—	LVM Physical Volume

/boot must be outside the LVM so GRUB can find it.

Logical Volumes inside Volume Group `vgcorp`

Logical Volume	Mount Point	Size	Purpose
`lvroot`	`/`	15 GB	Main filesystem
`lvhome`	`/home`	15 GB	User files
`lvvar`	`/var`	10 GB	Logs, databases, mail
`lvswap`	swap	4 GB	Swap space
(Free Space)	—	~5 GB	Reserved for later

🔧 Step by Step: Manual LVM Partitioning (GUI Mode)

1. Boot Kali → Select Graphical Install

Choose your language, region, user info, and so on until you reach:

2. Partition Disks → Choose Manual

3. Create `/boot`

Select free space → Create new partition → 1 GB
Make it Primary
Use as: Ext4 → Mount point: /boot

4. Create the LVM Physical Volume

Use remaining free space → Create new partition
Use as: physical volume for LVM

5. Configure LVM

Choose: Configure the Logical Volume Manager
Say yes to writing changes
Create volume group → Name it: vgcorp
Add the physical volume you just made

6. Create Logical Volumes

From within the LVM config screen:

Create LV: lvroot → 15 GB
Create LV: lvhome → 15 GB
Create LV: lvvar → 10 GB
Create LV: lvswap → 4 GB
Leave about 5 GB unused

7. Set Mount Points and Filesystems

Now assign mount points for each LV:

lvroot → / → ext4
lvhome → /home → ext4
lvvar → /var → ext4
lvswap → swap area

8. Finish and Install

Choose Finish partitioning and continue.
Kali installs with your custom layout!

What I Learned

LVM is powerful you can grow, shrink, or snapshot logical volumes later
Real setups isolate /var, /home, and swap for better performance, management, and security
Leaving space unused is a smart move in enterprise setups
Partitioning isn't scary once you understand the logic

What's Next

Now that I’ve installed it, I’m planning to:

Grow /home or create a new user with a dedicated LV
Practice LVM snapshots
Try encryption (LUKS + LVM)
Do a full CLI-based Kali installation just for fun

Final Thoughts

You learn best by doing and messing up. Tutorials are nice, but getting your hands dirty makes everything stick.

If you’re new to Linux — I challenge you:

Don’t settle for “Guided Install.” Go manual. Learn the real stuff.

You got this

Let me know if you want me to write a follow-up post on snapshots, growing LVMs, or CLI-based installs!

I Just Did Manual Partitioning in Linux And It Wasn't Scary at All

Jabulani Meki — Sat, 31 May 2025 23:49:21 +0000

I used to think manual partitioning in Linux was something only hardcore sysadmins or neckbeard wizards did. But today, inside a Kali Linux VM, I finally did it and it was way easier than I expected.

If you're learning Linux or feeling stuck at the partitioning screen, this post is for you.

What I Used

Distro: Kali Linux (latest)
Environment: VirtualBox
Disk size: ~27 GB

Why I Did It Manually

I didn’t want the installer to do everything for me like I was still on training wheels.

I wanted to understand:

What partitions Linux actually needs
Why we have things like /boot, /, swap, and sometimes /home
How to allocate space intentionally, not randomly

Step-by-Step Partitioning (Beginner-Friendly)

Here’s what I did, in plain English:

Selected the main virtual disk (/dev/sda)
Chose Manual partitioning
Created a /boot partition:
- Size: 512 MB
- Format: ext4
Created the / root partition:
- Size: ~15 GB
- Format: ext4
Created a swap partition:
- Size: 2 GB
(Optional) Created a /home partition with the remaining space
Wrote changes to disk and let Kali install

No scary terminal. No obscure jargon. Just making decisions with understanding.

What I Learned

Manual partitioning isn't hard you just need to know the basics
It gives you more control over how your system behaves
Knowing how Linux uses different mount points made everything click

Why This Matters (for Learners)

This was more than just clicking buttons it was a shift in mindset.

I now own my install, not just use it
I understand how to set up partitions for different use cases
I’m building real sysadmin confidence, one step at a time

What's Next?

Now that I’ve nailed manual partitioning, I want to:

Try LVM (Logical Volume Manager)
Experiment with encrypted root partitions
Eventually do this from the command line using fdisk or parted

Let’s Talk

Have you tried manual partitioning yet? What confused you the first time?

Let me know in the comments or feel free to share tips if you’re ahead of me. We’re all learning here

Linux's chmod vs. PATH: A Rant with Useful Explanations

Jabulani Meki — Fri, 30 May 2025 03:51:21 +0000

Picture this: You're following a tutorial, typing commands like a wizard, when suddenly...

./install.sh: Permission denied

(based on a true story)

Or worse:

command not found

Congratulations! You've met Linux's gatekeepers: chmod and PATH. Let's dissect them without the usual jargon overdose.

Part 1: chmod (Or, "Why Can't I Run My Own Damn Script?")

What It Actually Means

Every file in Linux has permissions like a nightclub bouncer:

Read (r): "You can look at this file."
Write (w): "You can edit this file."
Execute (x): "You can run this file (if it's a script/program)."

The chmod Command

It changes permissions. Syntax:

chmod [who][+/-][permissions] file

Examples:
Give yourself execute permission:

chmod u+x script.sh  # u = user (you), +x = add execute

Lock down a file (read-only for everyone):

chmod 444 file.txt  # 4 = read, for user/group/others

Pro Tip: Octal Notation

Nerds love numbers. Here's the cheat sheet:

Number	Permission
4	Read
2	Write
1	Execute

Add them up:

7 = 4+2+1 (read+write+execute)
6 = 4+2 (read+write)
5 = 4+1 (read+execute)

chmod 755 script.sh  # You get everything, others get read/execute

Part 2: PATH (Or, "Why Can't Linux Find My Program??")

What Is PATH?

A list of directories Linux checks when you type a command. Run this to see yours:

echo $PATH
# Output: /usr/local/bin:/usr/bin:/bin:/snap/bin

The "Command Not Found" Crisis

If you install a program (like rustc or npm) and get this error, it means:

The program isn't in any PATH directory.
Linux is being deliberately obtuse.

Fixes:

Add a Directory to PATH (Temporarily)

export PATH=$PATH:/path/to/your/program

(Dies when you close the terminal.)

Permanently Add to PATH

Edit your shell config file:

Bash: ~/.bashrc

Zsh: ~/.zshrc

Add this line:

export PATH=$PATH:/path/to/your/program

Then reload:

source ~/.bashrc  # or ~/.zshrc

Nuclear Option (Not Recommended)

sudo cp my_script /usr/local/bin  # Now it's in PATH... but pray you don't break anything.

Real-World Example: Installing a Python Script

Permission Denied?

chmod +x cool_script.py

"Command Not Found" After Moving It?

export PATH=$PATH:/home/yourname/scripts

TL;DR

chmod +x file.sh = "Linux, let me run this!"

export PATH=$PATH:/new/path = "Linux, LOOK HARDER."

Now go fix those errors before I rm -rf my patience.

Understanding File Types in Linux: ls -l Demystified

Jabulani Meki — Fri, 30 May 2025 00:52:11 +0000

If you've ever run ls -l in your Linux terminal and felt like you were staring at cryptic hieroglyphics, you're not alone. Let’s break down what that first column of characters actually means — and why it's super useful for any Linux user.

Example Output

-rw-r--r--  1 root root 18047 Dec 20  2017 alternatives.log  
drwxr-x---  2 root adm  4096 Dec 20  2017 apache2

Decoding the First Column

The first field has 10 characters, and it tells you two key things:

The type of file
The permissions (read, write, execute) for user, group, and others

Let’s focus on the very first character, which tells us the file type:

Symbol	File Type	What It Means
`-`	Regular file	Text, images, binaries, compressed files
`d`	Directory	A folder that holds other files
`l`	Symbolic link	A shortcut to another file or directory
`s`	Socket	Communication between processes
`p`	Pipe	Another way for processes to talk
`b`	Block file	Talks to hardware, like hard drives
`c`	Character file	Talks to hardware, one character at a time

Real World Example Breakdown

alternatives.log

-rw-r--r--  1 root root 18047 Dec 20  2017 alternatives.log

First character: - = regular file
Permissions: Owner can read/write, others can only read

Why This Matters

Knowing what these characters mean lets you:

Understand if you're dealing with a file or a folder
Quickly spot broken links, special devices, or hidden communication tools
Diagnose permission errors like "Permission denied"

TL;DR

Run ls -l to view file details
First character tells you the type of file
Master this and you’ll start navigating Linux like a pro

Linux Device Inspection — What to Do When Your Hardware Says “Nope.”

Jabulani Meki — Tue, 27 May 2025 03:30:47 +0000

Sometimes in Linux, your shiny new hardware does... absolutely nothing.

No blinking lights.

No sounds.

No signs of life.

You’re left wondering, is it dead? Is it me? Is it Linux?

Today, I dove into Linux hardware inspection figuring out what’s broken and where to start when your devices go silent. Here's what I learned, plus a few tips that might save you hours of hair-pulling.

Step 1: Is It Even There?

Before screaming at your OS, check if the hardware is actually being detected.

lspci — Listing PCI Devices

lspci

This command shows all the devices connected to your PCI bus (like graphics cards, network cards, etc.).

Want more info about a specific device? Use:

lspci -s [device address] -v

lsusb — Listing USB Devices

lsusb

This shows USB devices (keyboards, flash drives, webcams). If it doesn’t show up here try another port. USB ports die more than you'd think.

Tip: If the device is missing from both lsusb and lspci, you might be dealing with a hardware port failure, not a Linux issue.

Step 2: OK, It’s There… Why Isn’t It Working?

If the device shows up in lspci or lsusb but isn’t working right, it’s probably missing the software component needed to control it: a kernel module (a driver).

lsmod — List Loaded Kernel Modules

lsmod

This gives you a snapshot of all active kernel modules:

Module — the name of the driver

Size — memory used

Used by — which other modules depend on it

Some modules are like introverts at a party, they don’t do much unless someone else calls on them.

Another useful tool is modprobe (Load/Unload Kernel Modules)

Let’s say you want to reload a module to see if it fixes the issue:

sudo modprobe -r [modulename] # unload sudo modprobe [modulename] # load again

Use this to test if a module is flaky or to trigger reinitialization.

Step 3: Peek Into Linux's Brain

Linux stores tons of real-time hardware info in virtual filesystems: /proc, /sys, and /dev. These aren’t files on your disk — they live in RAM and reflect what the kernel knows right now.

/proc — The Kernel’s Thought Process

/proc/cpuinfo — Info about your CPU(s)

/proc/interrupts — What devices are requesting CPU attention

/proc/ioports — I/O ports currently in use

/proc/dma — Devices using Direct Memory Access (DMA)

It’s like opening the Matrix, but only if Neo was a system admin(I will let myself out).

/sys — Structured Hardware Data

While /proc mixes device and process info, /sys is more organized:

/sys/class/net/ — Networking

/sys/class/block/ — Storage

/sys/bus/usb/devices/ — USB devices

Think of /sys as /proc's more focused sibling specifically built for representing hardware and kernel interfaces.

/dev — Where Devices Become Files

In Linux, everything is a file even hardware.

Back in the prehistoric kernel 2.4 days, hard drives were named like this:

/dev/hda1, /dev/hda2 — Master IDE devices

Now, Linux uses:

/dev/sda, /dev/sdb, etc for SATA and SCSI(fun fun fact I really don't know what these are) devices

Fun Fact: These aren’t real files. They’re "special files" that represent devices. You can even pipe stuff into them (carefully!).

Quick Troubleshooting Flow

Device not working?
→ Run lspci or lsusb. If it’s not there, check your port/hardware.

Device is detected but unresponsive?
→ Run lsmod, look for the right module. Reload with modprobe.

Still stuck?
→ Dive into /proc and /sys for deeper inspection.

Need to identify storage devices?
→ Check /dev where drives and partitions show up.

Tools Worth Bookmarking

dmesg — Shows kernel boot and runtime logs (great for driver errors)

udevadm monitor — See live device event logs

hwinfo — Deep hardware summary (installable)

lshw — Hardware lister with class/type filtering

TL;DR Linux Device Inspection for Debugging Hardware Issues

Step 1: Use lspci (PCI devices) and lsusb (USB devices) to check if the OS detects the hardware.

Step 2: Use lsmod to view kernel modules (drivers); modprobe to reload or manually load them.

Step 3: Dive into /proc, /sys, and /dev for real time, low level hardware and device info.

Bonus tools: dmesg, udevadm monitor, hwinfo, lshw help with deeper diagnostics.

If the hardware isn’t detected: hardware issue or port failure.
If detected but not working: driver/module issue.
If still broken: poke around /proc, /sys, and logs like a true Linux sleuth.

Linux gives you all the tools you just have to know where to dig.

From Fired Accountant to Future Cloud Engineer

Jabulani Meki — Tue, 27 May 2025 00:28:02 +0000

Hi everyone

My name is Jabulani (still trying the nickname jay-sys), and this post is the beginning of a story I never thought I’d be telling, the story of how getting fired turned into the best thing that ever happened to me.

The Short Version:

Former accountant
Fired for struggling with ADHD in a rigid work environment
Diagnosed late, felt broken for a while
Found hope in tech — specifically cloud computing
Switched to Linux (Debian)
Now teaching myself cloud engineering full-time
Studying for LPIC-1, LPIC-2, and cloud certifications
Using this blog to stay accountable, document the process, and hopefully inspire someone like me

## Why I’m Doing This

I used to think I was just “bad at work.” I couldn’t keep up with long meetings, paperwork, and soul-draining tasks. Turns out, I wasn’t lazy my brain just worked differently. After getting fired, I spiraled. But after some hard reflection (and a lot of YouTube), I discovered cloud computing and something clicked. It felt flexible, creative, logical and possible.

I don’t have a computer science degree. I don’t come from tech. But I do have grit, curiosity, and something to prove (mostly to myself)

What You Can Expect from This Blog

I'll be sharing:

🧪 What I’m learning (Linux, cloud platforms, cert prep)
🧠 Struggles + breakthroughs with ADHD in tech
⚙️ Personal projects, CLI tools I love, lessons from failures
🧰 Resources I actually found useful
🎯 My progress toward becoming job-ready in cloud

This blog is my accountability partner, my digital journal, and my way of telling the world: You can start over. Even when it feels like you’ve got nothing figured out.

Let’s Connect

If you’re self-taught, neurodivergent, or just trying to break into tech from a non-traditional background I’d love to hear from you.

And if you’re further along the path, feel free to drop tips, encouragement, or even corrections I’m here to learn out loud.

Thanks for reading. Let’s build something real. 🌥️

— Jabulani (Jay-sys)

DEV Community: Jabulani Meki

How I Installed Kali Linux with Enterprise-Level LVM as a Beginner

Why I Did This

My Setup

Partition Plan

Disk Partitions

Logical Volumes inside Volume Group vgcorp

🔧 Step by Step: Manual LVM Partitioning (GUI Mode)

1. Boot Kali → Select Graphical Install

2. Partition Disks → Choose Manual

3. Create /boot

4. Create the LVM Physical Volume

5. Configure LVM

6. Create Logical Volumes

7. Set Mount Points and Filesystems

8. Finish and Install

What I Learned

What's Next

Final Thoughts

I Just Did Manual Partitioning in Linux And It Wasn't Scary at All

What I Used

Why I Did It Manually

Step-by-Step Partitioning (Beginner-Friendly)

What I Learned

Why This Matters (for Learners)

What's Next?

Let’s Talk

Linux's chmod vs. PATH: A Rant with Useful Explanations

Part 1: chmod (Or, "Why Can't I Run My Own Damn Script?")

The chmod Command

Part 2: PATH (Or, "Why Can't Linux Find My Program??")

Understanding File Types in Linux: ls -l Demystified

Example Output

Decoding the First Column

Real World Example Breakdown

Why This Matters

TL;DR

Linux Device Inspection — What to Do When Your Hardware Says “Nope.”

From Fired Accountant to Future Cloud Engineer

What You Can Expect from This Blog

Let’s Connect

Logical Volumes inside Volume Group `vgcorp`

3. Create `/boot`