> ## Documentation Index
> Fetch the complete documentation index at: https://resources.devweekends.com/llms.txt
> Use this file to discover all available pages before exploring further.

# DevOps Tools Mastery

> Master essential DevOps tools from Git to Kubernetes - with deep dives into internals

# DevOps Tools Mastery

> **DevOps** is the bridge between development and operations. Master the tools that power modern software delivery, from version control to container orchestration. This is not surface-level knowledge. We go deep.

This comprehensive course provides crash courses on six essential DevOps tools, taking you from beginner to mid-level proficiency with each. Every tool includes an optional internals deep dive for those who love understanding how things really work.

***

## Why DevOps Tools?

In modern software development, knowing how to code is table stakes. You need to understand the entire software delivery pipeline.

<CardGroup cols={2}>
  <Card title="Industry Standard" icon="building">
    These tools are used by every major tech company. Git, Docker, and Kubernetes are non-negotiable skills on any resume.
  </Card>

  <Card title="Career Growth" icon="chart-line">
    DevOps engineers are among the highest-paid roles in tech. These tools open doors to senior positions and leadership roles.
  </Card>

  <Card title="Efficiency" icon="rocket">
    Automate deployments, scale applications, and ship code faster with confidence. Stop doing manually what machines can do better.
  </Card>

  <Card title="Cloud Native" icon="cloud">
    Essential for working with AWS, GCP, Azure, and modern cloud infrastructure. The cloud speaks these languages.
  </Card>
</CardGroup>

***

## Course Roadmap

We cover six essential tools in depth, from fundamentals to practical application.

<Steps>
  <Step title="Git - Version Control">
    Master distributed version control, branching strategies, and collaboration workflows.
    [Start Learning →](/courses/devops-tools/git-overview)
  </Step>

  <Step title="Linux - The Foundation">
    Command line mastery, shell scripting, process management, and networking basics.
    [Explore Linux →](/courses/devops-tools/linux-overview)
  </Step>

  <Step title="Docker - Containerization">
    Build, ship, and run applications in containers. Master images, networking, and Docker Compose.
    [Learn Docker →](/courses/devops-tools/docker-overview)
  </Step>

  <Step title="RabbitMQ - Message Queuing">
    Asynchronous messaging, queue patterns, and building distributed systems with message brokers.
    [Discover RabbitMQ →](/courses/devops-tools/rabbitmq-overview)
  </Step>

  <Step title="Kafka - Event Streaming">
    Real-time data pipelines, stream processing, and high-throughput messaging at scale.
    [Master Kafka →](/courses/devops-tools/kafka-overview)
  </Step>

  <Step title="Kubernetes - Orchestration">
    Container orchestration, deployments, services, and managing applications at scale.
    [Dive into Kubernetes →](/courses/devops-tools/kubernetes-overview)
  </Step>
</Steps>

***

## What You'll Learn

Each crash course is designed to take you from zero to productive quickly.

<AccordionGroup>
  <Accordion title="Git Crash Course" icon="code-branch">
    **Duration**: 8-10 hours

    * Version control fundamentals and Git architecture
    * Branching, merging, and conflict resolution
    * Collaboration with GitHub/GitLab
    * Advanced workflows: rebase, cherry-pick, stash
    * **Internals Deep Dive**: Object model, SHA-1 hashing, packfiles, refs

    **Created by**: Linus Torvalds (2005) in 10 days for Linux kernel development
  </Accordion>

  <Accordion title="Linux Crash Course" icon="linux">
    **Duration**: 10-12 hours

    * File system navigation and operations
    * Users, groups, and permissions
    * Process management and systemd
    * Networking basics and SSH
    * Shell scripting and automation
    * **Internals Deep Dive**: Kernel, system calls, virtual filesystem, process scheduling

    **Created by**: Linus Torvalds (1991) as a free Unix-like OS
  </Accordion>

  <Accordion title="Docker Crash Course" icon="docker">
    **Duration**: 10-12 hours

    * Containerization concepts and Docker architecture
    * Images, containers, and registries
    * Dockerfile best practices and multi-stage builds
    * Networking, volumes, and data persistence
    * Docker Compose for multi-container apps
    * **Internals Deep Dive**: Namespaces, cgroups, union filesystems, OCI specification

    **Created by**: Solomon Hykes at dotCloud (2013), revolutionized deployment
  </Accordion>

  <Accordion title="RabbitMQ Crash Course" icon="rabbit">
    **Duration**: 6-8 hours

    * Message queuing fundamentals and AMQP protocol
    * Queues, exchanges, bindings, and routing
    * Messaging patterns: pub/sub, work queues, RPC
    * Clustering and high availability
    * Production deployment strategies
    * **Internals Deep Dive**: Erlang/OTP, message flow, quorum queues, credit flow

    **Created by**: Rabbit Technologies (2007), now part of VMware/Broadcom
  </Accordion>

  <Accordion title="Kafka Crash Course" icon="stream">
    **Duration**: 8-10 hours

    * Event streaming and Kafka architecture
    * Topics, partitions, and consumer groups
    * Producers and consumers with best practices
    * Kafka Streams for real-time processing
    * Clustering, replication, and operations
    * **Internals Deep Dive**: Log segments, ISR mechanics, leader election, consumer rebalancing

    **Created by**: LinkedIn (2011), now Apache project powering trillions of events per day
  </Accordion>

  <Accordion title="Kubernetes Crash Course" icon="dharmachakra">
    **Duration**: 12-14 hours

    * Container orchestration and K8s architecture
    * Pods, deployments, and services
    * ConfigMaps, secrets, and configuration
    * Networking, ingress, and load balancing
    * Storage: volumes and persistent storage
    * Windows and Linux container considerations
    * **Internals Deep Dive**: etcd, scheduler algorithms, controller patterns, CNI/CSI

    **Created by**: Google (2014), based on internal Borg system
  </Accordion>
</AccordionGroup>

***

## Prerequisites

<Info>
  **Recommended Background**:

  * Basic programming knowledge (any language)
  * Familiarity with command line (helpful but not required)
  * Understanding of basic networking concepts (IP, ports)

  **Tools Needed**:

  * A computer with Windows, macOS, or Linux
  * Terminal/command prompt access
  * Text editor (VS Code recommended)
  * Docker Desktop (for Docker/Kubernetes modules)
</Info>

***

## Learning Path

<CardGroup cols={3}>
  <Card title="Beginner Path" icon="seedling">
    **6-8 weeks**\
    Git → Linux → Docker\
    Build foundation in version control, command line, and containers
  </Card>

  <Card title="Backend Focus" icon="server">
    **8-10 weeks**\
    All tools with emphasis on RabbitMQ/Kafka\
    Perfect for backend engineers building distributed systems
  </Card>

  <Card title="DevOps Engineer" icon="gears">
    **10-12 weeks**\
    Complete course with all tools\
    Full DevOps toolkit for infrastructure and deployment
  </Card>
</CardGroup>

***

## Why These Six Tools?

These are not random choices -- they form the backbone of modern software delivery. Each one solves a fundamental problem, and together they cover the entire pipeline from writing code to running it in production at scale.

1. **Git**: Every company uses version control. Git is the standard. Without it, collaboration is chaos and rollbacks are guesswork.
2. **Linux**: 96.3% of the world's top 1 million servers run Linux. Your code runs on Linux even if you develop on a Mac or Windows. Understanding the OS your code runs on is not optional.
3. **Docker**: Containers solved "it works on my machine." Docker made containers accessible to every developer, not just infrastructure teams. It is the packaging format for modern applications.
4. **RabbitMQ**: When services need to talk to each other without blocking, when you need to survive failures gracefully, when you want to decouple your microservices -- RabbitMQ is battle-tested message queuing built on Erlang's telecom-grade reliability.
5. **Kafka**: For high-throughput event streaming, Kafka is unmatched. LinkedIn, Netflix, Uber, and thousands of companies use it to process trillions of events per day. Where RabbitMQ excels at smart routing, Kafka excels at raw throughput and replay.
6. **Kubernetes**: The de facto standard for container orchestration. It turns a fleet of machines into a single, programmable platform where you declare what you want running and Kubernetes makes it happen. Used by Google, Microsoft, Amazon, and most of the Fortune 500.

***

## Course Philosophy

<Note>
  **Practical First, Theory Second**

  Each module follows this pattern:

  1. **Why it matters**: Real-world context and use cases
  2. **Core concepts**: The fundamentals you need to know
  3. **Hands-on practice**: Commands, examples, and exercises
  4. **Best practices**: Production-ready patterns
  5. **Visual learning**: SVG diagrams for complex concepts

  We focus on what you'll actually use in real projects, not exhaustive documentation.
</Note>

***

## What Makes This Course Different

* **Beginner-friendly**: Assumes no prior DevOps knowledge
* **Depth where it matters**: Goes beyond basics to mid-level proficiency
* **Internals for the curious**: Every tool has an optional deep dive chapter for those who love understanding how things work
* **Interview-ready**: Covers the questions that come up in technical interviews
* **Historical context**: Understand *why* these tools were created
* **Visual learning**: Custom SVG diagrams for every major concept
* **Platform coverage**: Windows and Linux considerations throughout
* **Modern practices**: Current best practices, not outdated tutorials

***

## Course Outcomes

By completing this course, you will:

<Steps>
  <Step title="Version Control Mastery">
    Confidently use Git for solo and team projects, handle complex merge scenarios, understand the object model
  </Step>

  <Step title="Linux Proficiency">
    Navigate Linux systems, write shell scripts, manage processes and services, understand the kernel
  </Step>

  <Step title="Container Skills">
    Build and deploy containerized applications with Docker and Docker Compose, understand namespaces and cgroups
  </Step>

  <Step title="Messaging Systems">
    Design asynchronous systems with RabbitMQ and event-driven architectures with Kafka, understand distributed messaging
  </Step>

  <Step title="Orchestration">
    Deploy and manage containerized applications at scale with Kubernetes, understand the control plane
  </Step>

  <Step title="DevOps Mindset">
    Understand the complete software delivery pipeline from code to production, debug like a senior engineer
  </Step>
</Steps>

***

Ready to start your DevOps journey? Begin with [Git Crash Course →](/courses/devops-tools/git-overview)