Structured Learning Modules

Free Interactive DevOps & Cloud Courses

Free, interactive, bite-sized tutorials designed specifically for cloud newcomers and DevOps systems practitioners. Master the core tools of modern engineering with real-world analogies and instant concept checks.

Save Points & Parallel Universes

Git & GitHub Version Control

ESTIMATED STUDY TIME 45-60 Minutes

Real-World Analogy (Read This First!)

Imagine playing a difficult video game. Before a risky boss fight, you save your progress in a "save slot". If you die, you load that save slot. Git is a save-slot system for your folder. Instead of copying folders to project_v1, project_v2_final, Git takes lightweight snapshots (commits) and lets you load them instantly.

Course Modules

Core Concept

Have you ever saved a file as app_final_v3.py? In teams, that gets messy fast!

Version Control Systems (VCS) act as a code time machine, tracking every single character change, authorship, and version history.

• Centralized VCS (e.g., SVN) stores all history on a single central server. If it crashes or you lose internet access, you cannot commit or view logs.
• Distributed VCS (e.g., Git) gives everyone a full clone of the entire repository history locally. You can work, commit, and branch offline with zero central dependencies.

Compare Centralized vs. Distributed commands:

# Centralized (SVN): Must query the remote server to view history
svn log -r 100:200 http://svn.company-network.com/repo

# Distributed (Git): Query the complete database locally and instantly
git log --oneline -n 5

Concept Checkpoint

What is the main advantage of a Distributed VCS (like Git) over a Centralized VCS (like SVN)?

Core Concept

Let's clarify the two pillars of modern version control:
• What is Git? It is a local command-line engine that tracks changes in your files. Think of it as a personal diary tracking edits on your machine.
• What is GitHub? It is a cloud hosting platform for your Git repositories. While Git tracks files locally, GitHub is the web service where you back up, share, and collaborate on those diaries with teams.

Initializing Git (Theory & Practice):
To start tracking a folder, open your terminal inside it and run git init. This spins up a hidden folder named .git. This hidden directory holds Git's entire tracking database and history. If you delete this folder, you delete your project's history, turning it back into a standard folder.

What happens when Git is initialized (The 3 Stages):
Once initialized, Git splits your workspace into three zones:
1. Stage 1: Working Directory (Workspace): Your local sandbox where you write, modify, and delete code. These changes are local and not yet saved to history.
2. Stage 2: Staging Area (Index): A preview buffer or checkout cart. You select which specific edits should go into the next save point using git add.
3. Stage 3: Local Repository (Repo): The permanent, secure registry. Running git commit locks staged files in as a permanent snapshot.

The Flow: Working Directory —(add)—> Staging Area —(commit)—> Local Repo.
• What does the add command do? It copies modifications from your Working Directory to the Staging Area, telling Git: "I want this change in my next save point."
• What does commit mean? It permanently records the staged files as a checkpoint, along with a message describing the work.

Initialize, Stage, and Commit changes:

# 1. Initialize a new local Git repository
git init

# 2. Check the current status of your workspace
git status

# 3. Add a file to the Staging Area (checkout cart)
git add app.js

# 4. Commit the staged changes with a descriptive message
git commit -m "feat: setup initial web application server"

Concept Checkpoint

Which command moves files from the Working Directory into the Staging Area, preparing them to be committed?

Core Concept

To navigate Git, you must speak its language. Here is your developer glossary explained simply with examples and analogies:

• Repository (Repo): A project folder containing all code files and the hidden .git database. It is a folder with a built-in time machine.
• Server (Remote): A computer in the cloud (like GitHub) hosting a copy of your repo. It acts as the shared central hub for your team.
• Working Directory / Workspace: Your local sandbox folder on your PC where you edit, save, and delete code files.
• Commit: A permanent snapshot of your staged files in the local repository's history. Think of it as a "Save Game" state.
• Commit ID: A unique 40-character fingerprint (e.g., 5a1f28b...) created via cryptographic hashing (SHA-1). It guarantees security; if a single line of code is altered, its ID changes entirely!
• Snapshots (vs. Diffs): Unlike older systems that store line-by-line differences, Git takes a lightweight "snapshot" of all your files at that moment. If a file hasn't changed, Git doesn't duplicate it; it simply points to the previous version to keep things incredibly fast and compact.
• Tags: Human-readable bookmarks pointing to specific commits, usually release versions (e.g., v1.0.0). Think of them as sticky notes on a specific page of your history book.
• Push & Pull: push uploads local commits to the Server (GitHub). pull downloads remote commits from the Server and merges them into your local work.
• Branch: A parallel timeline. You can build a feature on a new branch without affecting the main timeline.

The Key Advantages of Git:
1. Distributed Nature: Work and view history fully offline.
2. High Performance: Operations are local and near-instant.
3. Data Integrity: Cryptographic verification protects history from silent corruption.

Log Commits, Create Tags, and Sync:

# View short Commit IDs (hashes) and messages
git log --oneline

# Create a release bookmark (Tag) pointing to the current commit
git tag v1.0.0

# Push local commits and tags to the remote server
git push origin main --tags

# Download and merge latest changes from teammates
git pull origin main

Concept Checkpoint

What is a Commit ID in Git and why is it important?

Core Concept

Before we start creating repositories, we need to install and configure Git on our machine. On a Linux system (like Ubuntu/Debian), we can install Git using the package manager. After installation, we must configure our identity (name and email) so that every commit we make is signed with our information. This is critical for collaboration as it shows who made what changes.

Key commands used during setup:
• sudo apt update && sudo apt install git -y: Updates package lists and installs the Git tool.
• git --version: Verifies that Git is installed and displays the active version.
• git config --global user.name "Your Name": Configures your commit author name.
• git config --global user.email "your.email@example.com": Configures your commit author email.
• git config --list: Lists all Git configurations active in the current environment.

Run installation and initial configuration commands:

# 1. Update and install Git on Linux (Ubuntu/Debian)
sudo apt update && sudo apt install git -y

# 2. Verify the installed Git version
git --version

# 3. Configure global identity
git config --global user.name "Keem"
git config --global user.email "keem@example.com"

# 4. Inspect your configuration settings
git config --list

Concept Checkpoint

Why do we need to configure our user.name and user.email after installing Git?

Core Concept

A branch in Git is simply a lightweight, movable pointer to one of your commits. Think of it as a parallel universe or timeline. When you initialize a repository, Git creates a default branch (typically named main or master). If you want to build a new feature (like a 'dark mode' toggle) or fix a bug without breaking the stable code on main, you create a new branch. Changes made on this new branch are completely isolated. Once you test and verify your new code, you can bring it back into the main branch.

Key commands:
• git branch: Lists all local branches. The active branch has an asterisk (*).
• git branch <branch-name>: Creates a new branch at your current commit.
• git checkout <branch-name>: Switches your working directory to the target branch.
• git checkout -b <branch-name>: A shortcut command that creates a new branch and immediately switches to it.

View, create, and navigate branches:

# 1. List all local branches (and see which one is active)
git branch

# 2. Create a new branch named 'feature-auth'
git branch feature-auth

# 3. Switch to the new branch
git checkout feature-auth

# 4. Shortcut: Create and switch to 'feature-payment' in one command
git checkout -b feature-payment

Concept Checkpoint

What is a Git branch and why is it useful?

Core Concept

Once Git is initialized, you begin the cycle of editing files, staging changes, committing snapshots locally, and syncing them to a remote server like GitHub. Here is a step-by-step breakdown of the full developer flow:

1. git init: Initializes a new local Git repository (creates the .git database).
2. Write / edit code in your files.
3. git status: Shows what files are modified, untracked, or staged.
4. git add .: Stages all new and modified files (prepares them for the commit).
5. git commit: Saves your staged snapshot permanently into local history (using -m to supply a message).
6. git status: Verifies that your working tree is clean.
7. git log: Shows a chronological list of commits.
8. git show <commitID>: Explores the exact diff and details of a single commit.
9. git remote add origin <url>: Connects your local repository to a remote repository hosted on GitHub.
10. git push -u origin main: Uploads your local commits on the main branch to the remote server, setting it as the default tracking branch.

Stage, commit, and link to GitHub:

# 1. Initialize repository and check status
git init
git status

# 2. Stage all modifications and commit
git add .
git commit -m "feat: add user login API endpoint"

# 3. View commit history and inspect latest commit
git log --oneline
# Replace 'a1b2c3d' with a real commit ID from your git log
git show a1b2c3d

# 4. Link to remote repository and push changes
git remote add origin https://github.com/user/demo-repo.git
git push -u origin main

Concept Checkpoint

Which command is used to link your local Git repository to a remote repository on GitHub?

Core Concept

When feature branches are finished, they must be merged back into the main timeline. If changes do not conflict, Git performs a merge automatically. However, if two branches modify the same line of the same file, Git pauses and signals a Merge Conflict, inserting conflict markers (<<<<<<<, =======, >>>>>>>) into the file. You must open the file, select the correct code, remove the markers, stage, and commit.

Additionally, two vital tools help manage daily workflow:
• git stash: Shelves your local changes temporarily, letting you switch branches or pull updates without committing half-finished code. You restore stashed work using git stash pop.
• git reset: Rolls back local branch states. --soft keeps your files changed and staged. --mixed (default) keeps files changed but unstaged. --hard completely deletes all modifications since the target commit.

Branch, Commits, and Merge Workflow:

Merge a branch, resolve conflicts, or stash changes:

# 1. Merge feature branch into main
git checkout main
git merge feature-auth

# 2. Stash temporary changes to clean your directory
git stash
# Do other tasks, then bring back your stashed work
git stash pop

# 3. Reset local repository state to last commit (Discarding changes)
git reset --hard HEAD

Concept Checkpoint

What happens during a Merge Conflict in Git?

Core Concept

Undoing changes in Git requires understanding the difference between history-altering commands and history-preserving commands:

• git reset vs. git revert:
- git reset <commitID> rewrites history by moving the branch pointer backward. It effectively erases commits that came after the target commit. Warning: Never use reset on public, shared branches as it disrupts your teammates' history.
- git revert <commitID> creates a new commit that applies the exact opposite changes of the specified commit. This preserves history, making it completely safe for shared branches.

• Rollbacks & Tags: Release tags like v1.0.0 act as immutable bookmarks. If a release breaks, you can use tags or reverts to restore a stable state.
• git clone <url>: Downloads an existing remote repository from GitHub to your local machine, setting up all tracking branches and repository history automatically.

Clone a repo and revert a commit:

# 1. Clone a remote project to your local computer
git clone https://github.com/user/project.git

# 2. Revert a specific commit (creates a new undo commit)
# Replace 'c7d8e9f' with the commit hash you want to undo
git revert c7d8e9f

# 3. Create a release tag and push it to GitHub
git tag v1.1.0
git push origin v1.1.0

Concept Checkpoint

When should you use git revert instead of git reset to undo a change?

Core Concept

In professional settings, teams use collaborative workflows on GitHub to review and test code before merging it:

• Forking: Creating your own personal copy of someone else's GitHub repository on your GitHub account. This allows you to experiment freely without affecting the original project.
• Pull Requests (PRs): A GitHub feature that allows you to propose changes from your fork or branch back to the main repository. Teammates can comment, review, and run tests on your changes before they are merged.
• Synced Workflows (Fetch vs. Pull):
- git fetch downloads the latest information from the remote server but does not modify your local working files.
- git pull is a shortcut that runs git fetch followed immediately by git merge, updating your local files with remote changes.

Synchronize changes with the team:

# 1. Fetch latest remote branches and changes (safe, no merge)
git fetch origin

# 2. Pull latest commits from remote main branch (fetches + merges)
git pull origin main

# 3. Create a branch, push it to GitHub, and prepare for PR
git checkout -b feature-payment-gateway
# (make changes and commit them)
git push -u origin feature-payment-gateway

Concept Checkpoint

What is the difference between git fetch and git pull?

Core Concept

Need a quick reference? Here is a comprehensive Cheat Sheet of essential Git commands to keep in your toolbelt:

1. Setup & Configuration
• git config --global user.name "Name": Configures your global author name.
• git config --global user.email "email@example.com": Configures your global author email.
• git init: Initializes a new local Git repository in the current folder.
• git clone <url>: Clones (downloads) a remote repository to your computer.

2. Local Changes
• git status: Lists modified, untracked, or staged files.
• git add <file>: Stages a specific file for the next commit.
• git add .: Stages all modified and new files.
• git commit -m "message": Commits staged changes with a descriptive message.
• git diff: Shows changes between your working directory and the staging area.

3. Branching & Merging
• git branch: Lists all local branches (active branch is marked with *).
• git branch <name>: Creates a new branch.
• git checkout <name>: Switches your working directory to the target branch.
• git checkout -b <name>: Creates a new branch and switches to it immediately.
• git merge <branch>: Merges the target branch into your active branch.
• git stash: Temporarily shelves (saves) uncommitted local changes to clean your directory.
• git stash pop: Restores stashed changes and deletes them from the stash list.

4. History & Logs
• git log: Shows a detailed commit history.
• git log --oneline: Shows a simplified, single-line list of commits.
• git show <commitID>: Explores details and line changes of a specific commit.
• git tag <name>: Marks a specific commit with a human-readable bookmark (e.g. v1.0.0).

5. Sharing & Collaborating
• git remote add origin <url>: Links your local repository to a remote server.
• git push -u origin <branch>: Uploads local commits and sets up tracking.
• git pull: Downloads remote commits and automatically merges them.
• git fetch: Downloads remote updates without merging them.

6. Undoing & Resetting
• git revert <commitID>: Creates a new commit that undoes the changes of a specified commit (safe for shared branches).
• git reset --hard <commitID>: Discards all commits and uncommitted changes back to a specific commit (destructive!).
• git reset --soft <commitID>: Undoes commits, but keeps your files changed and staged in the staging area.

Quick Reference Commands:

# Setup
git config --global user.name "Keem"
git config --global user.email "keem@example.com"
git init
git clone https://github.com/user/project.git

# Local Changes
git status
git add .
git commit -m "feat: add registration flow"
git diff

# Branching & Merging
git branch
git checkout -b feature-dark-mode
git merge feature-dark-mode
git stash
git stash pop

# Sharing & Syncing
git push origin main
git pull origin main
git fetch

# Undoing
git revert a1b2c3d
git reset --hard HEAD

Concept Checkpoint

Which sequence of commands would you run to temporarily shelve your uncommitted work, pull the latest changes from the remote server, and then re-apply your shelved work?

Understanding the Engine Room

Linux Operating System Essentials

ESTIMATED STUDY TIME 45-60 Minutes

Real-World Analogy (Read This First!)

Windows and macOS are like riding inside a passenger bus: you go where the steering wheel and routes take you, and you cannot touch the engine. Linux is like driving a manual transmission sports car. You are given a command terminal (the engine bay) where you can adjust, delete, or configure any gear or screw.

Course Modules

Core Concept

In Linux, there are no drive letters (like C: or D:). Everything starts at the root directory, represented by a single forward slash /. Your private files live in /home/username. System files live in folders like /etc (configs) or /bin (programs). Crucially, everything in Linux is represented as a file, even your hardware, network connections, and processes!

Navigate the file system:

# Print Working Directory (Where am I?)
pwd

# List files in the current folder (all files, detailed view)
ls -la

# Change directory to the root
cd /

Concept Checkpoint

Which symbol represents the absolute start (root) of the Linux filesystem?

Core Concept

Linux terminal commands follow a simple sentence structure:
command [flags] [arguments].
Flags (like -r or -f) act like adjectives—they modify how the command runs. Arguments act like nouns—they specify what the command should run on.

Using flags and arguments:

# Create a directory
mkdir documents

# Create a text file
touch documents/note.txt

# Copy the directory recursively (-r flag) to backup
cp -r documents documents-backup

Concept Checkpoint

What does the `-r` flag do in commands like `cp` (copy) or `rm` (remove)?

Core Concept

Every file and folder has permissions assigned to three parties:
1. User (u): The creator/owner.
2. Group (g): A team of users.
3. Others (o): Everyone else.
Permissions are: Read (r), Write (w), and Execute (x). You can add or revoke them using chmod.

View and edit file permissions:

# View detailed file details (shows permissions like -rwxr-xr-x)
ls -l run-app.sh

# Grant execution (run) permissions to the user
chmod +x run-app.sh

# Run the executable script
./run-app.sh

Concept Checkpoint

If a file permissions string is `-rwx------`, who can read, modify, and execute the file?

Core Concept

Instead of building massive complex applications, Linux provides small tools that do one thing well. You can chain them together. Use > to write command output into a file, and the pipe | to feed the output of one command as input directly into another command.

Chain commands with pipes:

# Find lines containing "ERROR" in a log file, count them, and save to a file
cat app.log | grep "ERROR" | wc -l > errors.txt

# Display the count
cat errors.txt

Concept Checkpoint

What is the purpose of the pipe `|` character in Linux?

Core Concept

Vim (Vi IMproved) is a highly configurable, command-line text editor built to make creating and changing any text very efficient. When you open a file in Vim, it starts in Command Mode by default. To edit the file, you must switch to Insert Mode by pressing i. To return to Command Mode, press Esc. To execute commands like saving or quitting, type : followed by the command (e.g. :wq to save and quit, or :q! to quit without saving).

Key commands in Command Mode:
• gg: Go to the first line.
• G: Go to the last line.
• dd: Delete (cut) the entire current line.
• yy: Copy (yank) the current line.
• p: Paste the copied line below the cursor.

Working with Vim Editor:

# 1. Open a file with Vim
vim config.txt

# 2. Press "i" to enter INSERT mode and type your text
# 3. Press "Esc" to exit INSERT mode and return to Command mode
# 4. Save and exit by typing:
# :wq
# Or quit without saving:
# :q!

Concept Checkpoint

How do you save and exit a file when editing in Vim?

Core Concept

Linux is a multi-user operating system. Users are classified into three categories:
1. Root User: The superuser with full system administrator permissions (User ID 0).
2. Regular Users: Standard accounts for day-to-day work (User IDs 1000+), such as keem.
3. Service Users: Automated system/application accounts (User IDs 1-999).

Regular users can execute administrative tasks using the sudo (Superuser Do) command if they are added to the sudoers configuration. Security details like encrypted passwords are stored in /etc/shadow, while user metadata is stored in /etc/passwd.

User management and sudo operations:

# 1. Create a new regular user named keem
sudo adduser keem

# 2. Add keem to the sudo group for administrative access
sudo usermod -aG sudo keem

# 3. Switch to the user keem
su - keem

# 4. Run an administrative command using sudo privileges
sudo apt update

Concept Checkpoint

Which file stores the user account encrypted passwords and password-related policy details?

Core Concept

Software on Linux is managed via package managers, which handle downloading, installing, and resolving dependencies. Debian-based systems (like Ubuntu) use apt and dpkg, while Red Hat-based systems (like RHEL/CentOS) use yum and dnf. Once installed, services are controlled using systemctl to start, stop, restart, enable (start automatically at boot), or disable them.

Install packages and manage services:

# --- For Debian/Ubuntu systems ---
# Update package registry and install Apache web server
sudo apt update && sudo apt install apache2 -y

# --- For Red Hat/CentOS/Fedora systems ---
# Install HTTPD web server
sudo yum install httpd -y

# --- Service Control (systemctl) ---
# Start the web service
sudo systemctl start apache2

# Enable the service to launch automatically at system boot
sudo systemctl enable apache2

# Check the active status of the service
sudo systemctl status apache2

Concept Checkpoint

Which command will configure a system service to start automatically whenever the system boots up?

The Web's Postal System

Computer Networking & Protocols

ESTIMATED STUDY TIME 45-60 Minutes

Real-World Analogy (Read This First!)

Sending a file to another machine is just like sending a letter through the postal mail.
• IP Address: Your physical home address.
• DNS: The public directory lookup matching names (e.g. "Google") to phone/address numbers.
• Port: The apartment number inside the building (directs traffic to the correct app).
• Packets: The envelopes containing fragments of your files.

Course Modules

Core Concept

A computer network is a collection of interconnected devices sharing resources and data.

Core Components:
• NIC (Network Interface Card): The physical or virtual hardware that allows a device to connect to a network.
• Transmission Media: Physical paths like copper Ethernet cables, fiber optics, or wireless radio waves (Wi-Fi) carrying the data signals.
• Hosts/Endpoints: Computers, servers, smartphones, and IoT devices that initiate or receive network data.
• Intermediary Devices: Equipment like hubs, switches, and routers that manage and direct the flow of data.

Network Classifications (Geographical Span):
• LAN (Local Area Network): Connects computers over a small distance—like a home, office, or school.
• MAN (Metropolitan Area Network): Spans a larger area than a LAN but smaller than a WAN, typically covering an entire city or campus.
• WAN (Wide Area Network): Connects networks across large physical distances (cities, states, or countries). The Internet is the world's largest WAN.

Inspect your active network interface configurations:

# Display list of network interfaces and link states
ip link show

# Modern command to see active network interfaces and their configuration (Linux)
ip address show

Concept Checkpoint

Which network classification would connect computer systems across multiple cities or countries?

Core Concept

To move data between computers, we use specialized networking hardware:

1. Network Switches (Layer 2)
Switches connect multiple devices together inside a single local network (LAN). They inspect incoming data and use MAC Addresses (physical hardware addresses burned into NICs) to deliver packets directly to the destination device, rather than broadcasting to all devices.

2. Routers (Layer 3)
Routers connect completely different networks (e.g., your home LAN to your Internet Service Provider's network). They read IP Addresses to determine the best path for sending packets across network boundaries.

3. Home Networks
In a standard home network, your "Router" is actually an all-in-one device combining:
• A Router (to talk to the external Internet WAN).
• A Switch (with physical Ethernet ports to connect local computers).
• A Wireless Access Point (AP) (broadcasting Wi-Fi signals for local devices).
• A DHCP Server (assigning IP addresses automatically to devices when they connect).

Inspect the local Address Resolution Protocol (ARP) table mappings:

# View local ARP table showing mapped MAC addresses of devices in your local LAN
arp -a

Concept Checkpoint

Which device is responsible for forwarding data packets between entirely separate networks based on logical IP addresses?

Core Concept

The OSI (Open Systems Interconnection) Model standardizes network communication into 7 logical layers. When an application sends data, it travels down the stack (encapsulation), adding headers at each layer. When received, it travels up the stack (decapsulation).

The 7 Layers (Top to Bottom):
• 7. Application: Direct interface for user applications (HTTP, HTTPS, SSH, DNS, FTP).
• 6. Presentation: Translates, encrypts, and compresses data (SSL/TLS, JSON, JPEG).
• 5. Session: Establishes, maintains, and terminates communication sessions (RPC, NetBIOS).
• 4. Transport: End-to-end reliability, flow control, and segmentation (TCP, UDP, Port numbers).
• 3. Network: Logical addressing, path determination, and packet routing (IP, ICMP, Routers).
• 2. Data Link: Node-to-node frame delivery, hardware addressing, and error detection (MAC, Ethernet, Switches).
• 1. Physical: Bit-level transmission of electrical, optical, or radio signals over cables and media.

OSI Encapsulation and Data Units (PDU):

# Encapsulation flow down the OSI stack:
# Application (Data) -> Transport (Segment) -> Network (Packet) -> Data Link (Frame) -> Physical (Bits)

# Decapsulation flow up the stack:
# Bits -> Frame (MAC Check) -> Packet (IP Route) -> Segment (Port Match) -> Data

Concept Checkpoint

At which OSI layer do switches and MAC addresses primarily operate?

Core Concept

An IPv4 address is a 32-bit logical address represented as four octets (e.g., 192.168.1.50). The entire IPv4 range spans from 0.0.0.0 to 255.255.255.255.

Public vs. Private IP Address Division:
• Public IPs: Globally unique addresses assigned to internet-facing devices (like servers or your home router's WAN interface). They are directly routable across the public internet.
• Private IPs: Used inside local networks (LANs). They are not routable on the public internet, meaning different organizations can reuse the exact same private addresses. Home routers use NAT (Network Address Translation) to translate private local IPs into a single public IP to browse the web.

RFC 1918 Private IP Address Ranges:
• Class A: 10.0.0.0 to 10.255.255.255 (Used in large enterprises; over 16 million hosts).
• Class B: 172.16.0.0 to 172.31.255.255 (Used in medium-sized networks).
• Class C: 192.168.0.0 to 192.168.255.255 (Used in small home/office networks; e.g. 192.168.1.X).

Lookup your public vs. private IP addresses:

# Find your private LAN IP address (look for inet under eth0 or wlan0)
ip addr show

# Find your public-facing WAN IP address via web API query
curl ifconfig.me

Concept Checkpoint

Which of the following IPv4 addresses is reserved for local private networks (Class B)?

Core Concept

A Protocol is a formal set of rules for format and transmission. Devices use specific port numbers to identify distinct applications.

Layer 4 Transport Protocols:
• TCP (Transmission Control Protocol): Connection-oriented and reliable. Uses a 3-way handshake (SYN, SYN-ACK, ACK), guarantees delivery, orders packets, and retransmits lost ones. (Web browsers, SSH, Databases).
• UDP (User Datagram Protocol): Connectionless and fast. Sends packets without handshakes or delivery checks. (Live audio/video, DNS, Gaming).

Layer 7 Application Protocols & Port Mappings:
• SSH (Port 22): Secure remote shell connection.
• Telnet (Port 23): Unencrypted legacy remote connection.
• DNS (Port 53 - TCP/UDP): Domain Name System. Translates readable domains (google.com) to IPs.
• HTTP (Port 80) & HTTPS (Port 443): Web traffic (HTTPS adds SSL/TLS encryption).
• DHCP (Ports 67 & 68 - UDP): Dynamic Host Configuration Protocol. Automatically assigns IP addresses, subnet masks, gateways, and DNS servers to local clients.

Inspect network connections and test target ports:

# List listening TCP (-t) and UDP (-u) sockets with numeric port numbers (-n) and process IDs (-p)
ss -tunlp

# Test if a port on a remote host is accepting connections (unencrypted)
telnet google.com 80

Concept Checkpoint

Which protocol and port combination is used to resolve user-friendly domain names to numerical IP addresses?

Core Concept

DevOps engineers use a standard set of command-line tools to diagnose network configurations and connectivity issues:

• ifconfig (Legacy) / ip addr show (Modern): Displays active network interface details and assigned IP addresses.
• ping <host>: Sends ICMP echo requests to test basic reachability and round-trip time (latency).
• /etc/hosts: A local text configuration file mapping hostnames to IP addresses. It bypasses DNS and acts as a local override.
• tracert <host> (Windows) / traceroute <host> (Linux): Traces the network path, showing each router hop a packet takes to reach its destination.
• netstat -tnlpu (Legacy) / ss -tulpn (Modern): Lists open ports, listening sockets, and the associated Process IDs (PID).
• ps -ef: Lists all running processes. Used alongside netstat/ss to inspect what application is holding a port.
• nmap <target>: A powerful port scanner to audit open ports and services on a remote host.
• nslookup <domain> / dig <domain>: Queries DNS servers for resource records (like A, CNAME, TXT, MX).
• route / ip route: Inspects or configures the local routing table and default gateway path.

Run basic diagnostic tests:

# 1. Check reachability and latency
ping -c 4 google.com

# 2. Lookup the DNS A (IP) record for a domain
dig google.com A

# 3. Trace packet path to the default gateway and beyond
traceroute google.com

# 4. View all processes running on the system to check daemon details
ps -ef | grep nginx

Concept Checkpoint

If you want to map a hostname to a custom IP address locally on a Linux machine, bypassing external DNS servers entirely, which file should you edit?

Standardizing Application Cargo

Docker & Container Basics

ESTIMATED STUDY TIME 45-60 Minutes

Real-World Analogy (Read This First!)

Historically, shipping cargo was chaotic. Piano crates, grain sacks, and barrels of oil were loaded directly onto ships—causing leaks, breakage, and loading delays. Global trade was revolutionized by standardized metal shipping containers. Anything fits in the box, and the box fits onto any crane, truck, or cargo ship. Docker does the same for code: wrapping your app, dependencies, and OS settings into a standard box that runs anywhere.

Course Modules

Core Concept

Before understanding Docker, we must understand how we run multiple isolated applications on a single physical machine using Virtualization.

What is Virtualization?
Virtualization uses software to create simulated environments called Virtual Machines (VMs) on a single physical hardware server. Each VM operates as an independent computer with its own hardware resources allocation (CPU, RAM, Storage).

The Architecture (The Hypervisor):
At the core of traditional virtualization is the Hypervisor (or Virtual Machine Monitor). It sits directly between the physical hardware and the VMs, allocating resources to each VM:
• Type 1 (Bare-Metal) Hypervisors: Run directly on hardware (e.g., VMware ESXi, Hyper-V).
• Type 2 (Hosted) Hypervisors: Run on top of an existing Operating System (e.g., VirtualBox, VMware Workstation).

Because every VM bundles a complete, heavy Guest Operating System, virtualization introduces high overhead and takes minutes to boot.

Docker: Advanced Virtualization:
Docker represents an advanced version of virtualization known as containerization (or OS-level virtualization). Instead of virtualizing hardware layers using a hypervisor and installing multiple heavy Guest OSs, Docker virtualizes the Operating System itself. Containers run directly on the host machine's OS kernel, isolating processes at the software level. This removes the hypervisor and guest OS overhead, making containers boot in milliseconds and consume minimal resources.

Compare Virtual Machine vs. Docker Container Architecture:

# Traditional Virtual Machine Stack:
# [ App / Libraries ] -> [ Guest OS ] -> [ Hypervisor ] -> [ Host OS/Hardware ]

# Docker Container Stack (Advanced Virtualization):
# [ App / Libraries ] -> [ Docker Engine ] -> [ Host OS Kernel ] -> [ Hardware ]

# Check your host machine's running kernel version:
uname -r

Concept Checkpoint

What is the role of a Hypervisor in traditional virtualization?

Core Concept

What exactly is Docker?
Docker is an open-source platform that packages applications and all their dependencies into standardized units called containers. This guarantees your code runs identically regardless of the underlying environment.

Docker vs. EC2 vs. VMware:
• VMware (VMs): Virtualizes hardware. Every VM bundles a full, guest OS kernel (heavy, gigabytes, boots in minutes).
• AWS EC2: Provides Virtual Machines in the cloud. It is IaaS. You still manage the guest OS, security patches, and VM overhead.
• Docker: Virtualizes the Operating System kernel. Multiple containers share a single host OS kernel, making them lightweight (megabytes), extremely fast to start (milliseconds), and highly efficient.

Advantages of Docker:
✔ Consistency: Eliminates "works on my machine" issues.
✔ Resource Efficiency: High density; run dozens of containers on a host that could only run 2-3 VMs.
✔ Portability: Build once, run anywhere (local, QA, production, multi-cloud).
✔ Rapid Deployment: Containers spin up and down almost instantly.

Disadvantages of Docker:
✗ Shared Kernel Risks: If the host kernel has a vulnerability, all containers on that host might be exposed.
✗ Cross-OS Limitations: You cannot run native Windows binaries inside a Linux-native container directly without emulation/VM layers.
✗ Networking & Storage Complexity: Managing persistent data and multi-host networking requires advanced orchestrators like Kubernetes.

Does a Container Have an Operating System?
No, a container does not have its own guest operating system kernel. It shares the host machine's OS kernel. However, a container does include a minimal OS "userland" filesystem (such as Alpine Linux, Debian, or Ubuntu utilities, libraries, and package managers) which provides the shell tools and libraries required by your application to execute.

Check container details and OS userland distribution:

# Run an interactive Ubuntu container and check its internal OS release details:
docker run -it ubuntu cat /etc/os-release

# Observe that it uses the host's shared kernel but has Ubuntu's file system and utilities!

Concept Checkpoint

Which statement accurately describes the Operating System (OS) structure of a running Docker container?

Core Concept

To master Docker, you must understand its architecture and how images are created:

Core Architectural Components:
• Docker Daemon (dockerd): The background service running on the host. It manages Docker objects (images, containers, networks, and volumes) and listens for API requests.
• Docker Client (docker): The CLI tool used by developers to communicate with the Docker Daemon via REST API commands.
• Docker Host: The physical machine or virtual server running the Docker Daemon.
• Docker Registry / Hub: A server registry storing images. Docker Hub is the default public registry where developers share pre-built images.
• Docker Container: A live, running, isolated sandbox instance built from a Docker Image.
• Docker Image: A read-only blueprint template containing code, libraries, and variables.

3 Ways to Create a Docker Image:
1. Pull an Image from Docker Hub: Use pre-built official images (e.g., `nginx`, `python`, `node`) directly from the public registry.
2. Build from a Dockerfile: Write a text file with instructions and build it using `docker build -t image-name .`. This is the standard practice for packaging custom apps.
3. Commit from an Existing Container: Run a container, make manual modifications inside it (install packages, update configs), and save its state into a new image using `docker commit `. (Not recommended for production due to lack of reproducibility, but useful for debugging!).

Pull, run, and commit changes to create an image:

# 1. Pull a base image from Docker Hub
docker pull alpine

# 2. Run it interactively and make a change
docker run -it --name test-box alpine sh
# (Inside container) echo "Hello from container" > /info.txt
# (Inside container) exit

# 3. Create (commit) a new image from the modified container
docker commit test-box my-custom-alpine

# 4. Verify your new image exists locally
docker images

Concept Checkpoint

What is the standard, best-practice way to create reproducible custom Docker images for production apps?

Core Concept

Here is the essential checklist of commands for running and inspecting containers:

• docker images: Lists all cached local images.
• docker search nginx: Searches Docker Hub for public images matching "nginx".
• docker pull <image>: Downloads an image from the registry to your host.
• docker ps: Lists running containers.
• docker ps -a: Lists all containers (active, stopped, or exited).
• docker start <name>: Starts a stopped container.
• docker stop <name>: Gracefully stops a running container.
• docker rm <name>: Deletes a stopped container from disk.
• service docker status (or systemctl status docker): Checks if the host's Docker Daemon service is active.

Explaining: docker run -it --name somename ubuntu /bin/bash
• docker run: Creates and starts a container in one go (combines `docker create` and `docker start`).
• -i (interactive): Keeps stdin open so you can type commands.
• -t (tty): Allocates a virtual terminal shell (pseudo-TTY) to interact with.
• --name somename: Assigns the custom name "somename" to the container instead of a random one.
• ubuntu: The source image to use.
• /bin/bash: The primary process command to execute inside the container.

Common Docker lifecycle operations:

# Check daemon status on Linux
service docker status

# Search for Nginx and pull it
docker search nginx
docker pull nginx

# Run an interactive ubuntu container
docker run -it --name cont1 ubuntu /bin/bash
# (Inside container, type: exit)

# Manage the container lifecycle
docker ps -a
docker start cont1
docker attach cont1
# (Exit container terminal, then stop and delete it)
docker stop cont1
docker rm cont1

Concept Checkpoint

Which command will list all containers on your host machine, including those that have stopped or exited?

Core Concept

To build your own images, you write a text file called a Dockerfile using specific instructions:

Core Dockerfile Instructions:
• FROM: Sets the base image (e.g. FROM node:18-alpine).
• RUN: Executes terminal commands during the image build process (creates a new layer).
• MAINTAINER (Deprecated): Declares the image author. (Use LABEL maintainer="email" instead).
• COPY: Copies files/folders from the host build context to the container filesystem.
• ADD: Similar to COPY, but can also fetch remote URLs and auto-extract tar archives.
• EXPOSE: Informs Docker which ports the container listens on at runtime (documentation).
• WORKDIR: Sets the active directory for subsequent instructions.
• ENV: Sets environment variables that persist in the running container.
• ARG: Sets temporary variables used only during the build phase (does not persist at runtime).
• CMD: The default command executed when the container starts. Can be overridden easily.
• ENTRYPOINT: Defines the main executable command of the container. Harder to override.

Analyzing Container Filesystem Changes: docker diff
The docker diff command shows modified files in a container's writeable layer. The prefixes are: A (Added), C (Changed), or D (Deleted).

Auditing Docker Resources:
• docker stats: Live stream of CPU, memory, network, and storage usage of running containers.
• docker system df: Shows disk usage of active images, containers, volumes, and build cache.

Examples of Dockerfiles & Auditing commands:

# --- Example 1: Web App Dockerfile (Node.js) ---
# FROM node:18-alpine
# WORKDIR /app
# COPY package*.json ./
# RUN npm install
# COPY . .
# EXPOSE 3000
# CMD ["node", "app.js"]

# --- Example 2: Python App Dockerfile ---
# FROM python:3.9-slim
# WORKDIR /app
# ARG BUILD_DEV=false
# ENV APP_ENV=production
# COPY requirements.txt .
# RUN pip install -r requirements.txt
# COPY . .
# EXPOSE 5000
# ENTRYPOINT ["python"]
# CMD ["main.py"]

# --- System Auditing Examples ---
# See live container stats (CPU/Memory usage):
docker stats

# Check Docker storage consumption:
docker system df

# Inspect changes made inside container "cont1":
docker diff cont1

Concept Checkpoint

What is the primary difference between the CMD and RUN instructions in a Dockerfile?

Core Concept

Docker containers are temporary. If a container is stopped and deleted, all files created inside it are destroyed. A **Docker Volume** links an internal container directory to a directory on your local laptop. This ensures your database logs and files are saved permanently.

Mount a volume to a database container:

# Run database container with a folder link (volume)
# Connects host /my/data directory to container database directory
docker run -d --name mysql-db -v /my/data:/var/lib/mysql mysql

Concept Checkpoint

Why do we need Docker Volumes?

Core Concept

What is a Docker Volume?
A Docker Volume is a directory managed by the Docker Engine (located in /var/lib/docker/volumes/ on the host) that exists outside the container's writable layer, providing persistent and high-performance data storage.

Benefits of Docker Volumes:
✔ Persistence: Data survives container crashes, restarts, and deletions.
✔ Performance: Higher I/O performance compared to writing to the container's storage layer.
✔ Decoupling: Separates runtime environments from application data.
✔ Sharing: Safe concurrent read/write access across multiple containers.

1. Volume from Docker CLI Command
Manage volumes directly using the Docker command-line interface (CLI):
• Create: docker volume create my-vol
• List: docker volume ls
• Inspect: docker volume inspect my-vol
• Delete: docker volume rm my-vol
Mount it: docker run -d -v my-vol:/app/data nginx

2. Volume Host Container (Bind Mounts)
You can mount a specific directory from your host machine's filesystem directly into the container. This is a Bind Mount:
• Command: docker run -d -v /host/path:/container/path nginx
This is ideal for development as changes made on the host immediately sync inside the container.

3. Create Volume from Dockerfile
Define mount points in the image using the VOLUME instruction:
• Example: VOLUME ["/data"]
When starting a container, Docker automatically creates an anonymous volume mapped to /data, preventing accidental data loss.

4. Share the Volume with Another Container
To share storage between containers:
• Multiple Mounts: Mount the same named volume to multiple containers: docker run -v shared-data:/data container1 and docker run -v shared-data:/data container2.
• Using --volumes-from: Inherit mounts from another container: docker run --name app -v shared-data:/data alpine and then start a backup/logging container using docker run --volumes-from app alpine.

Create, run, and share volumes via Docker CLI:

# 1. Create a named volume
docker volume create shared-logs

# 2. Run a web server container mounting the volume
docker run -d --name web-app -v shared-logs:/var/log/nginx -p 8080:80 nginx

# 3. Share the volume with a second container to monitor logs
docker run -it --name log-monitor --volumes-from web-app alpine tail -f /var/log/nginx/access.log

# 4. Check details of the volume
docker volume inspect shared-logs

Concept Checkpoint

How can you run a new container that inherits and shares all volume mounts from an already running container named "web-app"?

Core Concept

By default, containers run in an isolated network namespace. Any application running inside the container is unreachable from your host machine or the public internet. To allow external traffic to reach your containerized app, you must expose and publish network ports.

1. Exposing Ports via Dockerfile (EXPOSE)
The EXPOSE instruction inside a Dockerfile acts as documentation/metadata:
• Example: EXPOSE 8080
It informs users and orchestration tools (like Kubernetes) which ports the application listens on. Crucially, EXPOSE does NOT publish the port to the host machine. It only documents the intention.

2. Publishing Ports via Docker run (-p)
To map a port on the host machine to a port inside the container, use the -p (or --publish) flag during docker run:
• Syntax: docker run -p [host_port]:[container_port] [image]
• Example: docker run -p 80:8080 my-web-app
This maps port 80 on the host to port 8080 inside the container. Now, visiting http://localhost or the host's public IP will route traffic to port 8080 inside the container.

3. Publishing All Ports Dynamically (-P)
To avoid port conflicts on the host, use the uppercase -P (or --publish-all) flag:
• Example: docker run -P nginx
Docker will inspect the image's Dockerfile for EXPOSE statements and automatically publish all of them to random, free high-numbered ports (between 32768 and 60999) on the host machine. You can find the assigned port by running docker ps or docker port [container_name].

Map and expose container ports to the host:

# 1. Run an Nginx container publishing port 80 to host port 8080
docker run -d --name web-server -p 8080:80 nginx

# 2. Test accessing the server from the host machine
curl http://localhost:8080

# 3. Run a container with dynamic publishing (-P)
docker run -d --name web-dynamic -P nginx

# 4. Check which random host ports were assigned
docker port web-dynamic 80

Concept Checkpoint

What is the primary difference between the EXPOSE instruction in a Dockerfile and the -p flag in a docker run command?

Free Interactive DevOps & Cloud Courses

Git & GitHub Version Control

Real-World Analogy (Read This First!)

Course Modules

The Evolution of Version Control

Core Concept

Compare Centralized vs. Distributed commands:

Concept Checkpoint

Versioning: Git, GitHub & The 3 Stages

Core Concept

Initialize, Stage, and Commit changes:

Concept Checkpoint

Core Git Vocabulary & Concepts

Core Concept

Log Commits, Create Tags, and Sync:

Concept Checkpoint

Basic Git Setup

Core Concept

Run installation and initial configuration commands:

Concept Checkpoint

Git Branches

Core Concept

View, create, and navigate branches:

Concept Checkpoint

Commit, Push & Pull from GitHub

Core Concept

Stage, commit, and link to GitHub:

Concept Checkpoint

Merge and Stash

Core Concept

Merge a branch, resolve conflicts, or stash changes:

Concept Checkpoint

Git Revert and GitHub Clone

Core Concept

Clone a repo and revert a commit:

Concept Checkpoint

Collaborating with GitHub

Core Concept

Synchronize changes with the team:

Concept Checkpoint

Bonus: Git Command Cheat Sheet

Core Concept

Quick Reference Commands:

Concept Checkpoint

Linux Operating System Essentials

Real-World Analogy (Read This First!)

Course Modules

The Filesystem Tree

Core Concept

Navigate the file system:

Concept Checkpoint

Commands, Arguments & Flags

Core Concept

Using flags and arguments:

Concept Checkpoint

File Permissions & Owners

Core Concept

View and edit file permissions:

Concept Checkpoint

I/O Redirection & Pipes

Core Concept

Chain commands with pipes:

Concept Checkpoint

The Vim Text Editor

Core Concept

Working with Vim Editor:

Concept Checkpoint

User Accounts & Sudo Privileges

Core Concept

User management and sudo operations:

Concept Checkpoint

Package & Service Management

Core Concept

Install packages and manage services:

Concept Checkpoint

Computer Networking & Protocols

Real-World Analogy (Read This First!)

Course Modules

Network Foundations & Classifications

Core Concept