The Ultimate DevOps Bootcamp: All-in-One Course

A quick refresher on programming basics. We cover how code works, what compilers and interpreters do, and the core concepts you should know before diving into scripting and automation.

Understand how computers store and process data. We break down RAM, ROM, cache, and storage units so you have a solid foundation before working with servers and cloud machines.

Get a clear picture of what Linux is, why every DevOps engineer needs it, and how this section will prepare you with hands-on skills from day one.

A theory session covering Linux distributions, the open-source ecosystem, and why Linux dominates the server world. This sets the context before you start running commands.

Step-by-step walkthrough to set up your learning environment. We cover all the software and tools you need to install to follow along with the rest of the course.

Learn how to create a free-tier AWS account so you can practice on real cloud servers. We also cover billing alerts so you don't get any surprise charges.

If you're on Windows, this video shows you how to install Git Bash so you get a Linux-like terminal experience right on your desktop.

Your first hands-on with AWS. We launch an EC2 instance running Linux so you have a real server to practice all your Linux commands on.

Learn how to connect to your cloud server from your local machine using SSH. We cover key pairs, terminal commands, and troubleshooting common connection issues.

Start working with the Linux terminal. Learn pwd, cd, ls, mkdir, touch, and other essential commands to navigate and create files and folders.

Learn how to safely delete files and directories using rm and rmdir. We also go deeper into the ls command with its most useful flags and options.

Learn how to read and inspect file contents using cat, head, tail, more, and less. These are commands you'll use constantly as a DevOps engineer.

Master the cp and mv commands to copy, move, and rename files and directories. We also cover how to merge file contents using simple commands.

A visual walkthrough of the Linux directory structure. Understand what /etc, /var, /home, /tmp, /usr, and other key directories are used for.

Learn the vi text editor, the default editor on almost every Linux server. We cover insert mode, command mode, saving, quitting, and basic text editing operations.

Search for specific text patterns inside files using grep. We cover basic searches, case-insensitive matching, recursive search, and regular expressions.

The pipe operator lets you chain multiple commands together. This is one of the most powerful features of the Linux command line.

Search for files and directories by name, size, type, and modification time using the find command with practical examples.

A faster alternative to find. The locate command uses a pre-built database for speed. We cover how it works and when to use it over find.

The stream editor (sed) handles find-and-replace, line deletion, and text transformation directly from the command line. Essential for scripting and automation.

Understand the difference between root and regular users. We cover how sudo and su work and why running everything as root is a bad practice.

Linux file permissions control who can read, write, and execute files. This video covers the symbolic method (rwx) for owner, group, and others.

Master the numeric (octal) permission system. Understand what 777, 755, 644, and other common permission values mean and when to use them.

Create, delete, and switch between users using useradd, userdel, passwd, and su commands. Essential for server administration.

Understand how Linux groups work. Create groups, add users to groups, and manage group memberships for access control.

Change file and directory ownership using the chown command. Understand how ownership ties into the permission system.

Install, update, and remove software using apt and yum package managers. This is how you get tools and software onto your Linux servers.

Compress and extract files using zip, unzip, tar, and gzip. Essential skills for working with backups and file transfers.

Understand the difference between soft links and hard links. We also cover what inodes are and how the Linux file system tracks files internally.

The most commonly used networking commands in one video. Test connectivity with ping, make HTTP requests with curl, and download files with wget.

When things break, you need to debug. Use tools like traceroute, netstat, ss, and nslookup to troubleshoot network issues on Linux.

View running processes, monitor system performance in real time, and kill unresponsive processes using ps, top, and kill commands.

Monitor your server's health. Commands like df, du, free, and uptime help you check disk usage, memory consumption, and system uptime.

Don't memorize everything. Use man pages, info pages, and the help flag to quickly look up any command's syntax and options.

The awk command is your go-to for powerful text processing. We cover column extraction, pattern matching, and formatting output from log files and data streams.

Start, stop, restart, enable, and check the status of services using systemctl. This is how you manage Nginx, Apache, Docker, and other services.

Understand how Linux is built from the ground up. We cover the kernel, shell, hardware abstraction, and how they all work together.

Write your very first shell script. We cover the shebang line, making a script executable, and running it from the terminal.

Create variables, store values, and accept user input in your scripts using the read command. The building blocks of every script.

Add logic to your scripts. We cover if, else, elif, and nested conditions so your scripts can make decisions based on different scenarios.

Understand arithmetic, comparison, logical, and string operators in bash. Essential for writing conditions and calculations in your scripts.

Automate repetitive tasks using for loops, while loops, and until loops. We cover practical examples you'll actually use in real-world automation.

Organize your code with functions. Define, call, and pass arguments to functions to make your scripts clean and reusable.

Pass arguments to your scripts when you run them. We cover $1, $2, $@, $#, and how to handle dynamic inputs.

Environment variables control how your system and applications behave. We cover PATH, HOME, USER, and how to create custom variables.

Work with arrays in bash. We cover creating arrays, accessing elements, looping through arrays, and practical use cases.

A cleaner alternative to long if-else chains. Use case statements for menu-driven scripts and multi-option handling.

Read from files, write to files, append data, and check if files exist. Practical file operations every script needs.

Build a real-world automation script that creates backups, checks system health, and monitors critical services. A practical project to apply everything you've covered.

Schedule your scripts to run automatically using cron jobs. We cover crontab syntax, common schedules, and troubleshooting tips.

A hands-on demo where we build a script that automatically restarts failed services and cleans up old log files. Real DevOps automation in action.

Build a monitoring script that tracks CPU, memory, and disk usage and sends alerts when thresholds are crossed. A practical sysadmin tool you can use right away.

Understand what version control is, why it matters, and how Git helps teams track changes, collaborate, and avoid losing work.

A quick look at how Git was created by Linus Torvalds, why it replaced older tools, and how it became the industry standard for version control.

Install and configure Git on your machine. Set up your username, email, and default editor so you're ready to start tracking code.

Initialize a new Git repository from scratch. Understand what the .git folder contains and what happens behind the scenes when you run git init.

A shortcut for experienced users. Commit changes directly without explicitly staging them using git commit -a.

Compare changes between your working directory, staging area, and previous commits using git diff. Essential for code reviews.

Delete files from a Git repository the right way using git rm. Understand the difference between removing from Git vs removing from disk.

Create your first repository on GitHub. Understand the difference between public and private repos, and get familiar with the GitHub interface.

Connect your local Git repo to GitHub and push your code to the cloud using git remote add and git push.

Tag specific commits to mark release versions like v1.0, v2.0. We cover lightweight tags, annotated tags, and pushing tags to remote.

Download any public repository from GitHub to your local machine using git clone. Start contributing to existing projects.

Create new branches to work on features independently without affecting the main codebase. The foundation of team collaboration.

Clean up your repository by deleting branches that are no longer needed. We cover both local and remote branch deletion.

Push your local branches to GitHub so your teammates can see and review your work before merging.

A deeper look at how Git branches work internally. Understand pointers, HEAD, and how Git makes branching so fast and lightweight.

Merge one branch into another with confidence. We cover fast-forward merges, three-way merges, and what happens behind the scenes.

An alternative to merging that creates a cleaner commit history. Understand when to use rebase vs merge and the tradeoffs of each approach.

Conflicts happen when two people edit the same file. We walk through how to identify, understand, and resolve merge conflicts step by step.

Go back in time using git checkout, git revert, and git reset. Understand the difference between soft, mixed, and hard resets.

Save your work-in-progress without committing. Stash changes, list stashes, and apply them later when you're ready.

Forking lets you create your own copy of someone else's repository on GitHub. Understand the difference between forking and cloning, and how open-source contributions work.

Submit a pull request on GitHub the right way. We cover creating PRs, writing good descriptions, reviewing code, and merging PRs.