DEV Community

Malhar Gupte
Malhar Gupte

Posted on

My DevOps Journey - Understanding the Why and Linux Fundamentals

#devops #linux #automation #ubuntu

Starting a new learning journey always feels both exciting and overwhelming. This week, I decided to dive into the world of DevOps, and let me tell you - it's been an eye-opening experience. As someone looking to understand this field better, I chose to start with the fundamentals: understanding what DevOps really is and getting comfortable with Linux.

My learning sources for this week were TechWorld with Nana for DevOps concepts and TrainWithShubham for Linux fundamentals. Here's everything I learned and why it matters.

Understanding DevOps - More Than Just Buzzwords

What DevOps Actually Is

Before this week, I thought DevOps was just another tech buzzword - maybe some tools, maybe some automation. Boy, was I wrong! Thanks to Nana's clear explanations, I now understand that DevOps is fundamentally about culture and collaboration, not just tools.

DevOps is a methodology that bridges the gap between Development and Operations teams. It's about breaking down the traditional silos where developers write code and throw it "over the wall" to operations teams who then struggle to deploy and maintain it.

The Problems DevOps Solves

The more I learned about traditional software development approaches, the more I understood why DevOps became essential:

Before DevOps:

  • Deployments took days or weeks
  • Development and Operations teams barely communicated
  • Testing happened only at the end (too late!)
  • Environments were inconsistent ("it works on my machine!")
  • Manual processes everywhere = human errors everywhere
  • Slow feedback cycles meant issues were discovered late

After DevOps:

  • Multiple deployments per day (Netflix deploys thousands of times daily!)
  • Teams collaborate throughout the entire lifecycle
  • Continuous testing and integration
  • Consistent environments through automation
  • Automated processes reduce human error
  • Fast feedback loops catch issues early

Key DevOps Principles That Clicked for Me

  1. Automation Everywhere: If you're doing it manually more than once, automate it
  2. Continuous Integration/Continuous Deployment (CI/CD): Code changes are automatically tested and deployed
  3. Infrastructure as Code: Manage your infrastructure like you manage your application code
  4. Monitoring and Feedback: Constantly monitor and improve based on data
  5. Fail Fast, Recover Quickly: It's better to find problems early when they're cheaper to fix

Linux Fundamentals - The Foundation of Everything

Why Linux Matters in DevOps

Before diving into commands, I needed to understand why Linux is so crucial for DevOps:

  • Most servers run Linux (96% of the top 1 million web servers!)
  • Container technologies like Docker are Linux-based
  • Cloud platforms predominantly use Linux
  • Automation scripts are often written in shell
  • Cost-effective - no licensing fees unlike Windows servers

Essential Commands I Mastered This Week

Here are the commands I practiced and their real-world applications:

Navigation and File Operations:

# Basic navigation
pwd                    # Show current directory
ls -la                # List files with details
cd /path/to/directory # Change directory
mkdir project-folder  # Create directory
rmdir empty-folder    # Remove empty directory
rm -rf folder         # Remove directory and contents

# File operations
cp source destination  # Copy files
mv oldname newname    # Move/rename files
cat filename          # Display file contents
less filename         # View file page by page
head -10 filename     # Show first 10 lines
tail -f logfile       # Follow log file in real-time
Enter fullscreen mode Exit fullscreen mode

Permissions and Ownership:

chmod 755 script.sh         # Make script executable
chmod +x script.sh          # Another way to make executable
chown user:group filename   # Change file ownership
ls -l                       # View file permissions
Enter fullscreen mode Exit fullscreen mode

Process Management:

ps aux                      # Show all running processes
top                         # Real-time process monitor
kill 1234                   # Terminate process with ID 1234
jobs                        # Show active jobs
nohup command &             # Run command in background
Enter fullscreen mode Exit fullscreen mode

Understanding the Linux File System

The Linux directory structure finally makes sense to me:

  • / - Root directory (everything starts here)
  • /home - User directories (like C:\Users on Windows)
  • /etc - Configuration files (this is huge for DevOps!)
  • /var - Variable data, including logs (crucial for troubleshooting)
  • /usr - User programs and applications
  • /tmp - Temporary files (cleaned on reboot)
  • /opt - Optional/third-party software

File Permissions Deep Dive

This was initially confusing, but now I get it:

Permission Types:

  • Read (r) = 4
  • Write (w) = 2
  • Execute (x) = 1

Permission Groups:

  • User (owner)
  • Group
  • Other (everyone else)

Example: chmod 755 script.sh

  • Owner: 7 (4+2+1) = read, write, execute
  • Group: 5 (4+1) = read, execute
  • Other: 5 (4+1) = read, execute

Connecting the Dots - How This All Fits Together

Now I understand why these fundamentals are crucial for DevOps:

Server Management: DevOps engineers constantly SSH into Linux servers to deploy applications, check logs, and troubleshoot issues. Without Linux skills, you're stuck.

Automation Scripts: Whether it's deployment scripts, backup scripts, or monitoring scripts, they're typically written in bash and run on Linux systems.

Container Technology: Docker containers are essentially Linux processes. Understanding Linux concepts like processes, file systems, and permissions is essential for containerization.

Infrastructure as Code: Tools like Terraform and Ansible manage Linux servers. You need to understand what you're automating.

CI/CD Pipelines: Build servers are typically Linux-based. Your deployment scripts need Linux knowledge.

Challenges and Learning Moments

What Was Difficult

Command Syntax: Remembering all the flags and options. Why is it ls -la and not ls /a? Getting used to the Unix philosophy took time.

Vim Editor: I spent 10 minutes trying to exit Vim on my first try! :q! is now permanently etched in my memory.

Permission Numbers: Understanding why 755 means what it means required practice and repetition.

No Safety Net: Unlike Windows with "Are you sure?" dialogs, rm -rf / can destroy everything. The power requires responsibility.

Questions for the Community

I'd love to hear from experienced DevOps practitioners:

  1. What Linux commands do you use most frequently in your daily DevOps work?
  2. Any beginner-friendly resources for practicing Linux skills in a DevOps context?
  3. Any common mistakes I should watch out for as I continue this journey?

If you're also starting your DevOps journey, I encourage you to focus on these fundamentals. Don't rush to the flashy tools - master the basics first. Trust me, everything else will build on top of this foundation.

Resources mentioned:

See you next week for more learning adventures!

Top comments (0)