LVM in Linux Explained: PV, VG, LV with Example

🚀 Hands-on with LVM (Logical Volume Manager) in Linux 🐧 Today I explored how LVM makes disk management flexible, scalable, and powerful compared to traditional partitioning 💡 🔹 LVM Structure: 💽 Physical Volume (PV) – Disk/Partition 📦 Volume Group (VG) – Storage Pool 📂 Logical Volume (LV) – Usable Partition ✨ Why LVM? ⚡ Easily extend storage without downtime 🔗 Combine multiple disks into one pool 🛡️ Take snapshots for backup & recovery 🎯 Better control over disk management 🛠️ Commands I implemented: # Create Physical Volume pvcreate /dev/sdb1 # Create Volume Group vgcreate vg0 /dev/sdb1 # Create Logical Volume lvcreate -L 4.5G vg0 -n lv0 # Format the Logical Volume mkfs.ext4 /dev/vg0/lv0 # Create mount point mkdir /data # Mount the volume mount /dev/vg0/lv0 /data 📌 Result: Successfully created and mounted a new logical volume at /data ✅ 🔥 Learning by doing is the best way to grow in Linux & DevOps! #Linux #LVM #DevOps #SystemAdministration #Learning #IT #HandsOn

Day 28/100: Bundling It Up – Archiving & Compression in Linux 🗜️📦 Today’s Focus: In a real-world DevOps environment, servers generate massive amounts of log files and data (like the Jenkins logs I was working with today!). To save disk space and make transferring files over a network much faster, I learned how to properly archive and compress directories using the Linux CLI. 🛠️ The Tools I Mastered: I practiced bundling multiple files into a single archive and applying compression algorithms to shrink their size: The Mighty tar (Tape Archive): This is the undisputed king of Linux archiving. I learned the classic command flag combinations: tar -czvf archive.tar.gz [directory]: This creates a new archive (-c), compresses it using gzip (-z), shows me the progress verbosely (-v), and outputs it to a file (-f). tar -xzvf archive.tar.gz: The exact opposite! This extracts (-x) the compressed tarball back into a usable directory. I also explored the manual to see other powerful compression options like -j for bzip2 and -J for xz. zip & unzip: I also practiced using the standard zip -r command to recursively compress a directory. While tar is the Linux standard, zip is incredibly useful when I need to share artifacts with Windows environments! Why It Matters: Whether it is backing up application configurations, rotating system logs, or packaging up a build artifact to deploy to a server, we rarely move raw directories around. Compressing everything into a single "tarball" saves bandwidth, storage, and time! ⏳ #100DaysOfDevOps #100DaysOfCode #Linux #Tarball #SysAdmin #CentOS #Vagrant #CLI #DevOpsEngineer #TechJourney #DailyProgress #CloudComputing

Most Linux beginners think "Power On" to "Login Screen" is a single jump, but there is a hidden 8-step sequence happening in the background. During my 2 years managing production servers, I realized that 90% of "unfixable" boot errors are actually easy to solve once you visualize this specific flow. * The BIOS/UEFI runs a hardware check (POST) before handing the baton to your boot loader. * GRUB acts as the brain, reading your config files and loading the kernel into memory. * Systemd kicks in as the "Parent Process" to launch your targets and startup scripts. Mastering this sequence is a proven way to stop guessing and start troubleshooting like a pro. 🐧 Which of these 8 steps usually causes the most headaches in your environment? Follow for more and let's grow together Anis Salhi ________ #Linux #DevOps #SysAdmin #TechTips #Engineering

Most Linux beginners think "Power On" to "Login Screen" is a single jump, but there is a hidden 8-step sequence happening in the background. During my 7 years managing production servers, I realized that 90% of "unfixable" boot errors are actually easy to solve once you visualize this specific flow. * The BIOS/UEFI runs a hardware check (POST) before handing the baton to your boot loader. * GRUB acts as the brain, reading your config files and loading the kernel into memory. * Systemd kicks in as the "Parent Process" to launch your targets and startup scripts. Mastering this sequence is a proven way to stop guessing and start troubleshooting like a pro. 🐧 Which of these 8 steps usually causes the most headaches in your environment? Follow for more and let's grow together Muhammad Hashim _________ #Linux #DevOps #SysAdmin #TechTips #Engineering

🐧 Disk Usage Debugging in Linux (Find What’s Eating Space Fast) “Disk full” is one of the most common production issues. Here’s how engineers quickly find the problem 👇 💾 1. Check Overall Disk Usage "df -h" See which partition is full 📂 2. Find Large Directories "du -sh /* | sort -rh | head" Identify top space-consuming folders 📁 3. Drill Down Further "du -sh /var/* | sort -rh | head" Narrow down to exact location 📜 4. Check Logs "/var/log" often grows fast Clean old logs if needed 🗑️ 5. Clean Unused Files • Remove temp files ("/tmp") • Clear cache • Delete unused backups 🔍 6. Check Deleted but Open Files "lsof +L1" Find files deleted but still used by processes 💡 Key Insight Disk issues are not random — they leave clear traces if you check step by step. #Linux #DevOps #SystemAdmin #Troubleshooting #CloudEngineer #LinuxCommands #SRE

Day 11 — Systemd: Managing Services on Linux 🐧 Today I built a real custom systemd service from scratch — not just theory, actual files running on my EC2. What I built: A korelium-moniter.sh script that logs CPU and memory every 60 seconds to /var/log/korelium-moniter.log — then wrapped it as a systemd service so it runs automatically and restarts on failure. The mistake that stuck with me: Forgot chmod +x on my script → got status=203/EXEC error. Took me a while to debug. Now I'll never forget it. What the .service file does: → Restart=on-failure — if the script crashes, systemd brings it back → RestartSec=5 — waits 5 seconds before restarting → WantedBy=multi-user.target — starts automatically on boot Every time my monitor crashes, systemd revives it. That's production-grade thinking. Notes + files on GitHub 👇 🔗 https://lnkd.in/gWSfBVd8 Building every day. 🚀 #DevOps #Linux #Systemd #LearningInPublic #100DaysOfDevOps Timestamp: 3:42 PM IST, April 27, 2026

⚙️ What is the difference between the Linux Kernel and a Linux Distro ? 🚀 Kernel vs Distro Breaking Down the Difference  🧠 Core Concept: The Kernel is the engine of Linux it manages CPU, memory, devices, and system calls. The Distro is the complete operating system package combining the kernel with tools, libraries, and user interfaces to make Linux usable. ⚙️ Technical Breakdown:   ✅ Kernel handles hardware-level operations (processes, memory, I/O, security) ✅ Distro includes package managers, shells, GUIs, and applications ✅ Kernel is maintained by the Linux Foundation & global contributors ✅ Distros are built by vendors/communities (RHEL, Ubuntu, Oracle Linux, Debian, Fedora) 📌 Key Highlights:   ✔ Kernel = Core system controller ✔ Distro = Full OS environment ✔ Together they form the backbone of modern computing 💡 Why It Matters:   For enterprise environments especially Oracle deployments knowing how the kernel interacts with your distro (like Oracle Linux or RHEL) ensures better scalability, stability, and security. #Linux #Kernel #Distro #RHEL #Ubuntu #OracleLinux #Debian #SysAdmin #DBA #DevOps #OperatingSystem

🚀 Week 2 How switching from Apache to NGINX improved performance on an embedded Linux device Recently worked on optimizing a service running on a constrained embedded Linux system (custom Yocto build), where CPU usage and latency were becoming bottlenecks under load. The problem The system was using Apache (process/thread-based model), which: • Consumed higher CPU under concurrent requests • Struggled with scalability on limited hardware • Introduced latency spikes under load The approach We migrated the service to NGINX (event-driven architecture), focusing on: • Efficient handling of concurrent connections using non-blocking I/O • Reducing per-request overhead • Better resource utilization for constrained environments The result • Reduction in CPU usage • Improved response latency under load • More stable performance with concurrent requests Key takeaway Architecture matters. In resource-constrained systems, moving from a process-based model to an event-driven model can significantly improve efficiency and scalability. This experience reinforced how important it is to: → understand system internals, not just frameworks → choose the right architecture for the workload → measure performance, not assume it I enjoy working on problems at the intersection of systems, performance, and real-world constraints. #Linux #NGINX #Apache #PerformanceEngineering #EmbeddedSystems #Backend #Cplusplus

Linux From Scratch has been called impractical for years. Fine. Of course it is. It takes at least forty hours, and that is assuming things go reasonably well. When you finish, there is no package manager waiting to rescue you. No clean update path. No layer of polish smoothing over the hard parts. Every binary on that machine exists because you compiled it. Every configuration file exists because you wrote it. That much is obvious. The real question is whether that matters. It does. More than most people are willing to say out loud. Not because LFS belongs on a production server. It does not. Not because it is the smartest way to run a modern environment. It is not. That misses the point completely. The point is what it does to your understanding. Because there is a kind of knowledge that only comes from doing something the hard way, from first principles, with your own hands. You do not get that from browsing a wiki. You do not get it from skimming documentation and nodding along. You get it by getting stuck. By getting it wrong. By sitting in a chroot at two in the morning, staring at a kernel that refuses to compile, and staying there until the system finally makes sense. That experience does something documentation alone cannot do. It burns the lesson in. It forces the abstractions to fall away. It turns Linux from a product you use into a system you actually understand. And once you have that, you keep it. Read more here: https://lnkd.in/gtiUeRhb #Linux #LinuxFromScratch #OpenSource #SystemsEngineering #DevOps #Infrastructure #SoftwareEngineering #OperatingSystems #LearnByDoing #LFS