Mímir, Keeper of the Well of Wisdom
Mastering Linux: The Comprehensive Guide
https://www.udemy.com/course/mastering-linux/
Year : 2026
Language : English
Level : Beginner Level
Category : IT & Software
Subcategory : Operating Systems & Servers
Duration : 71h 21m
Lectures : 615
Rating : 4.7/5 (3,554 reviews)
Students : 27,604
INSTRUCTOR(S)
HEADLINE
Gain an almost unfair advantage by unlocking the Power of
Linux: 70 hours of hands-on training. The ONLY course you
need
WHAT YOU'LL LEARN
* Career Boost: Stand out in tech roles such as System
Administrator, Web Developer, Software Engineer, DevOps
Engineer, Site Reliability Engineer, and more
* Master the CLI: You will never feel lost on the command line
again. Daily tasks will be quicker and easier than ever
before
* Holistic Comprehension: Grasp the 'why' behind Linux. This
makes learning intuitive and engaging. No annoying 1:1
memorisation needed!
* Engaging & Interactive: Dive into a fun learning experience
with numerous examples, hands-on projects, and quizzes to
reinforce and test your knowledge
* Package Management & Application: Navigate package systems
seamlessly and apply knowledge in real-world projects
* Advanced Bash Scripting: Create sophisticated scripts using
loops, tests, APIs, and JSON for automation and complex
tasks
* Comprehensive Linux Insight: Understand processes, user
groups, permissions, and get acquainted with system boots
and
storage mounts
* All-Encompassing Guide: Dive into the definitive Linux
course,
meticulously crafted to be the only resource you'll ever
need
REQUIREMENTS
* Basic Computer Literacy: Familiarity with general computer
operations (opening files, searching the web,...)
* An Open Mind: Eagerness to learn and explore new concepts
* A System to Practice On: Access to a computer (Windows, Mac,
or Linux) to run Linux simulations or installations. We will
install everything required together - you pretty much just
need a few GB of extra storage
* Reliable Internet: For accessing course materials, videos,
and
online resources
WHO IS THIS COURSE FOR
* Beginners: This course is the perfect solution for beginners
looking to become experts in Linux thanks to its easy-to-
follow exercises and self-paced structure
* Intermediate Users: If you already have some experience, you
can benefit from delving deep into the intricacies of Linux
operations and learning more complex operations that only
the
most advanced engineers can do
* Advanced Professionals: Challenge yourself with
sophisticated
Bash scripting exercises and explore the high-level
functionalities of Linux, so you remain at the forefront of
your field
* Web Developers & IT Specialists: Gain invaluable skills that
seamlessly integrate into your professional toolkit, making
you stand out for more senior or infrastructure roles
* Enthusiasts & Hobbyists: Satiate your curiosity, turning
passion into prowess with a structured learning path, all
while indulging in a subject you love
DESCRIPTION
Do you sometimes feel lost with the command line and want to
use
Linux with confidence? Do you want to boost your daily
efficiency and gain a significant advantage for your tech
career? This is where our Mastering Linux course steps in. Led
by a top Udemy instructor with real-world expertise, we
simplify
Linux for you. Featuring 70+ hours of content, hands-on
projects, and practical scenarios, and many quizzes - this
course is all you need. Dive in, sharpen your skills, and give
your tech career a big lift. Course Highlights: Career
Amplification: Propel your career forward. This course
positions
you as a sought-after Linux authority, primed for elite tech
engagements. Holistic Learning: Imparted by a distinguished
instructor with seasoned experience at flagship tech giants.
Experience a harmonious blend of real-world relevance and
innovative teaching methods. Stand Out in Tech Roles: Go
beyond
rote learning and grasp the reasoning behind each Linux
concept.
This enriches your learning experience, and makes you stand
out
from others. Have Fun While Learning: Dive into a dynamic
learning experience packed with practical examples, engaging
quizzes, and real-world scenarios. Our interactive approach
ensures you remain captivated while absorbing and applying
Linux's core principles. Learning has never been this
enjoyable
and impactful. What is the structure of this course? Bash CLI
Mastery: Dive deep into the Command Line Interface (CLI) with
Bash and transform your day-to-day tech tasks. By mastering
this
foundational element, you'll not only become comfortable in
the
command line environment but also gain the confidence to
handle
daily operations seamlessly. From executing basic commands to
managing files, the CLI is an indispensable tool for any Linux
enthusiast. Through our hands-on exercises and real-world
scenarios, you'll learn to use Bash with precision, making
everyday tasks easier and more efficient. Diving Deep into
Linux: This segment takes you to the heart of Linux, preparing
you for tasks like server administration, network
configuration
or workstation setups. By exploring the intricate details of
Linux processes, user groups, and permissions & SELinux,
you'll
gain a foundational understanding how everything works. Delve
into the boot process, package management, firewalls,
networking. This knowledge ensures you're well-equipped to
manage servers, set up Linux networks, or tackle any related
challenges. By the end of this section, you'll navigate the
Linux ecosystem with confidence, ready to handle real-world
applications with precision. Advanced Bash Scripting: With
your
foundational knowledge in place, this section dives deeper
into
the real-world applications of Bash scripting. Learn to
automate
repetitive tasks, monitor system health, process vast
datasets,
and seamlessly integrate with web services. Delve into
crafting
intricate scripts that utilize loops, tests, and APIs. This
module ensures you're equipped with both theoretical insight
and
hands-on skills, ready to tackle diverse challenges in various
tech environments. Why This Course Stands Out: Purposeful
Learning: Emphasis on comprehension over plain memorization.
Practical Integration: Each session is meticulously crafted
for
real-tech applicability. Comprehensive Curriculum: Over 70
hours
of curated content for exhaustive learning. Mentorship
Excellence: Absorb wisdom from a top-tier Udemy maestro.
Practical Engagements: Dive into projects that mirror real-
world
scenarios. Collaborative Learning: Vibrant forums for
collective
discussions and inquiries. Everlasting Access: Pay once,
benefit
forever. Embrace Your Linux Future: Are you ready to say
goodbye
to feeling lost with Linux and the command line? Are you eager
to command Linux like a professional and give your tech career
a
substantial boost? Click that enroll button now and take the
first step towards unlocking the power of Linux. You got
nothing
to loose and a world of opportunities to gain!
COURSE CONTENT
Chapter 1: ----- Part 1: INTRODUCTION & INSTALLATION -----
1. Intro
2. Getting the Most out of this Course
3. Slides of this Course (as .pdf)
4. What is Linux?
5. What are Linux Distributions?
6. Heads-up: Ubuntu 24.04 LTS / 25.05
7. Installing VirtualBox
8. Installing Ubuntu [VirtualBox]
9. Configuration of Ubuntu [VirtualBox]
10. For your convenience: Configuration Recap
11. Hint: Problem with shared Folder
12. Read before installing CentOS Stream
13. Installing CentOS Stream [VirtualBox]
14. Configuration of CentOS Stream [VirtualBox]
15. For your convenience: Configuration Recap
16. How to create a Snapshot? [VirtualBox]
17. Outlook
Chapter 2: [Installation on MacOS with Apple Silicon Chips]:
UTM
18. Important: Only for macOS users
19. Installing UTM
20. The link to download Ubuntu
21. Installing Ubuntu [UTM]
22. Configuration of Ubuntu [UTM]
23. For your convenience: Configuration Recap
24. Installing CentOS Stream [UTM]
25. Configuration of CentOS [UTM]
26. For your convenience: Configuration Recap
27. Outlook
Chapter 3: ----- Part 2: BASH CLI -----
28. Bash CLI Intro
Chapter 4: First Steps in the Terminal
29. Important: If you've already been using the Terminal
30. Setting up your Terminal
31. Outputting Text: the Command `echo`
32. Displaying and Changing the Current Directory: the
Commands `pwd` & `cd`
33. Listing Content in Directories: the Command `ls`
34. Path Types: Absolute Paths vs. Relative Paths
35. Executing Multiple Commands using `;`
36. Getting Terminal Help: `man` and `--help`
Chapter 5: First Steps with Linux
37. Intro
38. Information User Managment
39. User Management Basics: System Accounts, Regular Users,
Superusers
40. Elevating Privileges: the Command `sudo`
41. Optional [Troubleshooting]: When `sudo` does not work
42. What is Package Management and how does it work?
43. Updating and Installing Software in Ubuntu: apt
44. Updating and Installing Software in CentOS Stream: dnf
45. Extra lecture (optional) [MacOS]: How to use Bash in
MacOS (Part 1)
46. Extra lecture (optional) [MacOS]: How to use Bash in
MacOS (Part 2)
47. Making the Most of Role Plays [Beta]
Chapter 6: File Management (Part 1) - Organize Files &
Directories
48. Important: If you've already been using the Terminal /
Linux
49. Intro
50. Introduction to Labs
51. Creating Files and Directories: the Commands `touch` &
`mkdir`
52. Moving and Copying Files: the Commands `mv` & `cp`
53. Deleting Files and Directories: the Commands `rm` &
`rmdir`
54. Exercise Intro: Website File Management
55. Exercise: Website File Management
56. Solution: Website File Management
57. File Name Selection by Pattern Matching: Globbing with
`*`
58. Advanced Globbing Wildcards: `?`, `[0-9]`, `**`
59. Pitfalls of Globbing: Avoiding Traps in Pattern Matching
60. Download the materials for the next exercise
61. Exercise: Navigate a nested folder structure using
Globbing
62. Exercise: Navigate a nested folder structure using
Globbing
63. Solution: Navigate a nested folder structure using
Globbing
64. Extra lecture (optional): Sophisticated File Searching:
the Program `find`
Chapter 7: File Management (Part 2) - Handle Text Files
65. Intro
66. The eBook in the next lecture
67. Viewing (Text) File Content: the Command `cat`, `head`
and `tail`
68. Reading Large Text Files: the Command `less`
69. Counting Words and Measuring Disk Usage: the Programs
`wc` & `du`
70. Text Editing in the Terminal: the Command-Line-Editor
nano
71. Exercise Intro: Analyze a Log File
72. Exercise Materials: Analyze a Log File
73. Solution: Analyze a Logfile
Chapter 8: Redirection - Manage Data Streams
74. Intro
75. Writing and Appending to (Text) Files: the Redirection
Operators `>` & `>>`
76. The Standard Streams: stdin, stdout, stderr
77. Managing Error Messages: Redirecting stderr (and stdout)
78. Redirecting stdout to stderr (Part 1)
79. Redirecting stdout to stderr (Part 2)
80. Redirecting stdin
Chapter 9: Pipes - Data Processing through Command Chaining
81. Intro
82. What is a Pipe (`|`)?
83. Dual Output: the Utility `tee`
84. Sorting and Removing Duplicates: the Commands `sort` and
`uniq`
85. Searching for Patterns in Text: the Utility `grep`
86. Character Replacements and Reversal: the Utilities `tr`
& `rev`
87. Selective Extraction: the Program `cut`
88. Text Substitution with the Stream Editor `sed`
89. Exercise: Webserver Log File Analysis
90. Exercise Material: Webserver Log File Analysis
91. Solution: Webserver Log File Analysis
Chapter 10: Environment Variables - Manage your Shell
Configuration
92. Intro
93. What is a shell?
94. What are Environment Variables and how to access them?
95. The Environment Variables HOME, PWD & USER
96. Creating and Deleting Environment Variables: the
Commands `export` & `unset`
97. Efficient Command Execution: the variable PATH
98. Extra lecture (optional): The File Hierarchy Standard
99. Modifying the PATH variable
100. Extra lecture (optional) [Python Script]: Creating
Custom Executable Files
101. Utilizing Environment Variables for Data Transfer into
Programs (Python example)
102. Retrieve the Default Shell: the Variable SHELL
103. Storing Custom Shell Configurations: .bashrc and other
Bash Startup Files
104. Editing Bash Startup Files with the Command-Line Editor
nano
105. Command Shortcuts: Creating Aliases with the `alias`
Command
106. Adjusting Shell Behavior: the Command `set`
107. Fine-Tuning Shell Behavior (Bash): the Command `shopt`
Chapter 11: Project - Create a Custom Bash Prompt
108. Intro
109. Why There Are No Labs for Customizing the Bash Prompt
(PS1)
110. Customizing your Shell Prompt: the Variable PS1
111. Terminal Color Control via Escape Sequences
112. Bold Text in the Terminal:`infocmp` and additional
Terminal Capabilitites
113. Crash-course: Command Substitution `$(...)` in Bash
114. Streamlining Terminal Control: the Program `tput`
115. Important: PS1 fix for upcoming Exercise
116. Exercise: Customize your Terminal Prompt
117. Solution: Customize your Terminal Prompt
Chapter 12: Shell Expansions - How Commands are parsed
118. Intro
119. Filename Expansions: `*`& `?`
120. Referencing the Home Directory: the Tilde expansion `~`
121. Accessing and Manipulating Values: Variable and
Parameter Expansions `${...}`
122. Word splitting & the variable IFS
123. Quoting Mechanisms: No Quotes vs. Single Quotes '...'
vs. Double Quotes "..."
124. Caution: Common Pitfalls in Shell Expansions
125. Escaping: the Backslash character `\`
126. Expanding Strings of Characters: the Brace Expansion
`{...}`
127. Leveraging Command Output: the Command Substitution
`$(...)`
128. Dynamic Input & Output: Process Substitution with
`<(...)`& `>(...)`
129. Recap
Chapter 13: ----- Part 3: LINUX -----
130. Part 3: Linux Intro
Chapter 14: Files on Unix - The "Everything is a File" Concept
131. Intro
132. What is a File?
133. Flexible File Referencing with Symlinks (Symbolic
Links)
134. Extra lecture (optional) [Windows]: Symlinks on Windows
135. Referencing Inodes with Hardlinks
136. Troubleshooting: The Inode Limit
137. Buffered vs. unbuffered I/O
138. What is a Device?
139. Examples of Pseudo-Devices: `/dev/null`, `/dev/random`,
`/dev/urandom`,...
140. System Insights: Files in the Folder `/proc`
141. Filesystem Hierarchy Standard (Part 1): / (root), /bin,
/boot, /dev, /etc
142. Filesystem Hierarchy Standard (Part 2): /home, /lib,
/media, /mnt, /opt
143. Filesystem Hierarchy Standard (Part 3): /proc, /root,
/run, /sbin, /srv, /sys
144. Filesystem Hierarchy Standard (Part 4): /tmp, /usr,
/var, /lost+found
145. Streamlining Filesystem Structure: the Project usrmerge
146. Wrapping Up the Labs
Chapter 15: Linux User Management - Groups, Permissions &
Access Control
147. Intro
148. Managing Users: The Roles of `/etc/passwd`,
`/etc/shadow` & `/etc/group`
149. Creating and Securing New Users: `useradd` & `passwd`
150. Extra lecture (optional): How Password Expiration works
151. Change User Options: the Command `usermod`
152. Deleting Users: the Command `userdel`
153. How do Groups work?
154. Add and Remove Group Members with `usermod`, `adduser`,
`deluser`
155. Creating & Modifying Custom Groups: the Command
`groupadd`
156. Switching Users: the Command `su`
157. Heads-up: EDITOR for visudo
158. Elevating User Privileges with `sudo` (Deep Dive)
159. Executing Commands as Different User with `sudo -U`
160. Advanced `sudo` Configuration: the File `/etc/sudoers`
161. Assigning & Changing File Permissions with `chmod` &
`chown`
162. Setting File Permissions Efficiently: `chmod` with
Numerical Values
163. Managing Permissions and Ownerships for Directories
164. Setting Default File Permissions: the Command `umask`
165. Securing Directories: Setting the Sticky Bit
166. Advanced File Permissions: SUID (Set User ID) and SGID
(Set Group ID)
167. Best Practices for User Management
Chapter 16: Linux Processes - Orchestrate System Operations
168. Intro
169. Important [CentOS]: Note for CentOS Users
170. What are Processes?
171. Monitoring Processes: The `ps` Command
172. Optional [MacOS]: Different Behavior of `ps` on MacOS
173. Extra lecture (optional): BSD-style parameters (`ps
aux`)
174. Inspecting Context Switches: How Multitasking Works
175. Controlling Process Priorities by Setting the Niceness
176. Identifying Process IDs with `pgrep` and adjusting
their Priority with `renice`
177. Influencing Processes with Signals
178. Materials regarding the Upcoming Lessons
179. Sending Signals with the `kill` command & the
Interruption Signal SIGINT
180. Terminating Processes Soft and Hard: the Signals
SIGTERM vs SIGKILL
181. Controlling Processes with the Signals SIGHUP, SIGSTOP
and SIGCONT
182. The `kill` Command vs the Program `/usr/bin/kill`
183. Sending Signals to Multiple Processes: the `killall`
Command
184. Process Endings: Process Reaping, Orphan & Zombie
Processes
185. Overview of Process States
186. Monitoring System Activity: the `top` Program
187. Advanced `top` Usage (Deep Dive)
188. Monitoring System Activity: the `htop` Program
(Alternative to `top`)
Chapter 17: Job Control in Bash - Navigate Background and
Foreground Operations
189. Intro
190. What Jobs are and how to start your First Background
Job (using `&`)
191. Job Listing and Foregrounding: The `jobs` and `fg`
Commands
192. Notice: resuming job with 'fg'
193. Suspending and Resuming Jobs with `fg`
194. Terminating Jobs with `kill`
195. Suspending Jobs with Output using `stty`
196. Job Synchronization with the `wait` Command
197. Keep Programs Running: the Command `nohup` vs `&`
Chapter 18: Package Management with `APT` & `dpkg` [Ubuntu] -
Streamline Software Handling
198. Intro
199. Installing Software manually with the Debian Package
Manager (dpkg)
200. Installing Software manually with the Advanced Package
Tool (APT)
201. Managing Linux System Updates and Upgrades with APT:
Best Practices
202. Autoremoving Old Dependencies to Maintain a Lean System
203. The file `sources.list` and Ubuntu's Repository
Structure
204. Update: source.list
205. Managing Custom Repositories (by the Example of WineHQ)
206. Using Third-Party Repositories with Personal Package
Archives (PPAs)
207. Extra lecture (optional): Verifying Package Integrity
with Debsums
208. Dependency Management with APT: Resolving Conflicts and
Debugging Techniques
209. Best Practices for Resolving Dependency Conflicts with
APT
210. Extra lecture (optional): Reconfiguring Packages after
Installation with dpkg
211. Package Management with Snap: Dealing with Self-
Contained Applications
Chapter 19: Package Management with `DNF` [CentOS] -
Streamline Software Handling
212. Intro
213. The Red Hat Package Manager (RPM) Format
214. Installing Software manually with the DNF (Dandified
Yum) Package Manager
215. What are Repositories?
216. What are Software Dependencies?
217. How Weak Dependencies Enhance Software Efficiency
218. How Backward Weak Dependencies Enhance Software
Functionality
219. Notice for the next lecture
220. Managing Package Dependencies in DNF: Preventing
Unintended Removals
221. How to Safely Upgrade and Cautiously Downgrade with DNF
222. Excluding Packages from Upgrades for Ensuring
Compatibility
223. Balancing System Stability and Convenience with
Automatic Updates
224. Software Version Control with DNF Modules for Ensuring
Stability (Part 1)
225. Software Version Control with DNF Modules for Ensuring
Stability (Part 2)
226. EPEL-Release: Extra Packages for Enterprise Linux
227. Taming Dependency Challenges in CentOS: Strategies for
Smooth System Updates
228. Extra lecture (optional): Software Flexibility with
Snap on CentOS and RHEL
Chapter 20: The System Boot Process & Systemd - Understand the
Startup Mechanisms
229. Intro
230. The GRUB2 Bootloader: Safely Modifying Configuration
for Linux System Startup
231. Bridging Hardware and Software: How does a Kernel work?
232. The Service Management Tool systemd
233. Complexity vs Flexibility: The systemd Controversy
234. Deep Dive into Boot and Service Management with systemd
235. Managing Apache 2 as systemd Unit: Installation,
Configuration, and Control
236. Process Grouping & Control: Efficient Resource
Management with cgroups
237. Example: Controlling Resources with systemd and cgroups
238. Systemd Targets: Achieving Efficient System States
239. Enabling and Disabling Units: Managing Services with
systemctl
240. Systemd Unit Files: Structuring and Optimizing Services
241. Customizing systemd Unit Files (Part 1)
242. Customizing systemd Unit Files (Part 2)
243. Boot-time Program Launch with systemd: Creating and
Managing Unit Files
244. Scheduling Delayed Tasks with systemd Timers: Precision
and Efficiency
245. Advanced systemd Timers: Precision Scheduling with
Repeated Calendar Events
246. Journald and journalctl: Effective System Logging and
Analysis
Chapter 21: Volumes, Partitions & Mounts - Integrate and
Manage Filesystems in Linux
247. Intro
248. Managing Storage with Partition Tables: MBR vs GPT
249. Understanding Storage Units: Differentiating Kibibytes,
Mebibytes and more
250. Adding a Virtual Hard Drive [VirtualBox]
251. File Systems Overview and Creating a first Partition
252. Disk Partitioning with `parted`: CLI Management and
Best Practices
253. Volumes vs Partitions: Mounting and Accessing Storage
254. Manual Drive Mounting: Enhancing Flexibility
255. Partition Mounting Options (ext4): `ro`, `rw`,
`noexec`, `nosuid` and `noatime`
256. Advanced Mounting and Permission Configuration for
exFAT
257. Efficient Drive Mounting with /etc/fstab
258. Extra lecture (optional): Mounting FTP Servers with
curlftpfs
259. Extra lecture (optional): Securing FTP Server Mounts
with .netrc Files
260. Extra lecture (optional): Automatically Mounting FTP
Servers through /etc/fstab
261. The SMART Protocol: Proactive Drive Health Monitoring
262. Ensuring Data Integrity: File System Checks
263. Automatic File System Checks for Enhanced Reliability
[Ubuntu]
264. Extra lecture (optional): Recovering Data from a
Compromised File System
265. Reducing File Systems and Partitions
266. Expanding File Systems and Partitions
Chapter 22: Logical Volume Manager (LVM) - Handle Storage
Dynamically
267. Intro
268. A quick heads-up
269. Setup: VM with Multiple Storage Drives
270. The Logical Volume Manager (LVM): Flexible Storage
Management
271. A quick heads-up: /dev/sdb1 vs. /dev/sdb2
272. Initializing Physical Volumes with LVM
273. Creating a Volume Group with LVM
274. Creating and Managing Logical Volumes with LVM
275. Expanding Volume Groups & Safely Removing Physical
Volumes in LVM
276. Resizing Logical Volumes with LVM
277. Dismantling LVM: Safely Removing Logical Volumes and
Groups
278. CentOS Boot Process with LVM Integration
279. Advanced LVM Features: RAID, Thin Volumes, and Snapshot
Chapter 23: Extra chapter (optional): Full Software Upgrade &
Troubleshooting Tutorial
280. Intro
281. Full Software Upgrade on Ubuntu
282. Troubleshooting: Identifying Kernel Issues &
Facilitating Data Backup
283. Solving: Using `chroot` and GRUB Configuration for
Recovery
284. Prevention: Kernel Safeguarding
285. Outro: Best Practices and Common Challenges
Chapter 24: Extra chapter (optional): Cron Jobs - Automate and
Schedule Tasks
286. Intro
287. Cron Variants Overview: `vixie-cron`, `anacron` &
`cronie`
288. The Cron Daemon `crond` & Crontab Files: Editing and
Permissions
289. Task Scheduling in Crontab Files: Understanding the
Crontab Syntax
290. Managing Cron Output: Email Notifications & MAILTO
Configuration [Ubuntu]
291. Managing Cron Output: Email Notification & `sendmail`
Integration [CentOS]
292. The `flock` command: Ensuring Data Consistency through
File Locking
293. The /etc/crontab File: Defining System-Wide Tasks
294. Managing Tasks with anacron: Flexible Scheduling
[Ubuntu]
295. Managing Tasks with anacron: Flexible Scheduling
[CentOS]
296. Best Practices for Cron Jobs: Smart Scheduling,
Security and Maintenance
Chapter 25: Networking - Arrange and Manage Linux
Communication Channels
297. Intro
298. What is the Internet?
299. The `ip` command: Inspecting Network Configurations
300. The tool Wireshark: Monitoring Network Traffic (incl.
Ethical Considerations)
301. Overview: The Open Systems Interconnection (OSI) model
302. OSI Layer 1/7: The Physical Layer
303. Managing Layer 1: Controlling Physical Devices with
Software
304. OSI Layer 2/7: The Data Link Layer
305. Understanding Layer 2 Hardware: Bridges, Switches and
Wireless Access Points
306. OSI Layer 3/7: The Network Layer
307. How Subnets enhance Network Efficiency
308. What are Subnet Masks and how do they work?
309. The Address Resolution Protocol (ARP): the Dynamics of
IP Packet Transmission
310. Managing IP Addresses with the `ip` command: Listing,
Adding & Removing
311. Navigating Network Routing: Inspecting Routing Tables &
adding Routes
312. Dynamic Host Configuration Protocol (DHCP): Managing
IP Addresses on Networks
313. Inspecting DHCP Logs with `systemd-networkd`:
Troubleshooting IP Address Issues
314. Inspecting DHCP Logs with `NetworkManager`:
Troubleshooting IP Address Issues
315. The program `ping`: Inspecting Network Connectivity by
ICMP
316. Exploring Network Routes with `traceroute`: Diagnosing
Latency and Routing
317. How `traceroute` works: Mapping Internet Packet Paths
and TTL
318. OSI Layer 4/7: The Transport Layer
319. TCP (Transmission Control Protocol) Ports: The Key to
Data Routing
320. Essential TCP & UDP Ports
321. The TCP Handshake Process: Establishing Reliable
Network Connections
322. Port Scanning with Nmap
323. Scan Types in Nmap: TCP-SYN-Scan, TCP-connect-scan and
UDP-scan
324. Extra lecture (optional): Network Address Translation
(NAT)
325. OSI Layer 5/7: The Session Layer
326. OSI Layer 6/7: The Presentation Layer
327. OSI Layer 7/7: The Application Layer
328. The Domain Name System (DNS) Protocol: Resolving Domain
Names to IP Addresses
329. The `host` command & DNS Records Types: A, AAAA, CNAME,
MX and NS
330. Extra lecture (optional): Manual DNS Resolution with
the `dig` command
331. DNS Vulnerabilities and Security Measures
332. Manual Domain-IP Mapping: Editing the `/etc/hosts` File
on Linux
333. The mDNS (Multicast DNS) Standard: Configuring
Hostnames in Local Networks
334. The Hypertext Transfer Protocol (HTTP): Browser
Inspection and Telnet Testing
335. IPv6 Overview: Advantages, Enhanced Security and Dual-
Stack Transition
Chapter 26: SSH - Securely Connect to Remote Servers
336. Intro
337. What is the Secure Shell (SSH)?
338. Networking (bridged)
339. Networking (NAT)
340. Our first SSH Connection
341. Security tips (part 1, port)
342. Security tips (part 1, port) [CentOS]
343. Security tips (part 2, users)
344. How to Not Lock Yourself Out
345. Public Private Key
346. Disabling Password Login
347. How to Keep a Connection Open
348. Fingerprints
349. File transfers with SFTP
350. The Utility Screen
Chapter 27: Project: Set up a Web Server
351. Intro
352. The LAMP Setup
353. Installing LAMP [CentOS]
354. Installing LAMP [Ubuntu]
355. How to configure Apache?
356. Configuration of Apache [CentOS]
357. Adding a Port to httpd [CentOS]
358. Configuration of Apache2 [Ubuntu]
359. How does a VirtualHost work?
360. Creating a VirtualHost [CentOS]
361. Creating a VirtualHost [Ubuntu]
362. How do the Log Files work?
363. PHP [CentOS]
364. PHP [Ubuntu]
365. Setting up MySQL
366. Creating a MySQL Admin User
367. Installing phpmyadmin [CentOS]
368. Installing phpmyadmin [Ubuntu]
369. Preparing the DB for WordPress
370. Installation of WordPress
371. How to Override Configuration via htaccess
372. How to Password Protect a Directory
373. Access phpmyadmin through Tunnel
Chapter 28: Extra chapter (optional): Firewall - Control
Network Traffic
374. Intro
375. Why we need a Firewall
376. Why we are not learning iptables
377. The Architecture of firewalld
378. Installing firewalld on Ubuntu
379. What are Services in firewalld?
380. Opening and Closing Services
381. Zones in firewalld
382. Outlook firewalld
Chapter 29: SELinux (Security Enhanced Linux) - Enforce Robust
Access Control Policies
383. Intro
384. Discretionary Access Control
385. The Problem with Discretionary Access Control
386. Mandatory Access Control
387. Enabling and Disabling SELinux
388. File Contexts in SELinux
389. How SELinux Protects you
390. Changing File Context (`chcon`, `restorecon`)
391. Setting Default Contexts (`semanage fcontext`)
392. Security Attributes of Processes
393. A quick look at the SELinux Policy
394. Targeted Policy and how Processes are Started
395. SELinux Booleans
396. How to fix Policy Violations
397. Managing Ports
398. Disabling SELinux during Boot
399. Summary and Outlook
Chapter 30: Linux Distributions - Explore the Landscape from
Red Hat to Arch Linux
400. Intro
401. The Red Hat family: Fedora, CentOS Stream, Red Hat
Enterprise Linux
402. The extended Red Hat family: Rocky Linux, AlmaLinux,
Oracle Linux
403. The Debian family: Debian, Ubuntu, Kali Linux,
Raspberry Pi OS, Linux Mint
404. Ubuntu Linux and its variants: Ubuntu Server, Kubuntu,
Xubuntu, Lubuntu
405. The SUSE family: SUSE Linux Enterprise, openSUSE: Leap
& Tumbleweed
406. Arch Linux
407. Gentoo Linux
408. How to choose a Linux Distribution?
Chapter 31: ----- Part 4: BASH SCRIPTING -----
409. Part 4: Bash Scripting Intro
Chapter 32: Bash Scripting Basics (Part 1) - Leverage
Variables for Dynamic Scripts
410. Intro
411. Our first Bash Script
412. What is a Shebang?
413. Comments in Bash
414. Variables in Bash
415. Bash Variables vs. Environment Variables
416. How to not declare a Variable
417. The `declare` command
418. Unsetting Variables
419. Reading Input (`read`)
420. Advanced `read` Usage
421. Reading the Contents of a File
422. Let's Create a Program
423. Exercise (Overview): System Info Script
424. Exercise: The starting script for my solution
425. Solution: System Info Script
426. Solution (download): System Info Script
Chapter 33: Bash Scripting Basics (Part 2) - Build Robust
Scripts
427. Intro
428. Pipe vs Process Substitution
429. Splitting a Script into Multiple Files
430. Making a Script accessible through PATH
431. Best Practices for Shell Scripts
432. Paths in Shell Scripts
433. The `shellcheck` Program
434. Writing Shell Scripts with Visual Studio Code
Chapter 34: Numeric Variables & Arithmetic Operations - Work
with Numerical Data
435. Intro
436. Basic Math in Bash
437. Integer Variables
438. Read ints in Bash
439. How to use Decimals
440. Extra lecture (optional): `awk`
Chapter 35: Access External Data - Retrieve JSON Data from
APIs
441. Intro
442. How an HTTP Request works
443. [Windows]: Install git Bash Environment on Windows
444. First steps with `curl`
445. Extra lecture (optional): How the Download Bar from
`curl` works
446. What is JSON?
447. The Program jq
448. Exercise (Materials): Fetch Weather Data
449. Exercise (Overview): Fetch Weather Data
450. Solution (Materials): Fetch Weather Data
451. Solution: Fetch Weather Data (Part 1; API)
452. Solution: Fetch Weather Data (Part 2; JSON)
Chapter 36: Tests & the `if` Clause - Implement Logical
Evaluations & Conditional Logic
453. Intro
454. Exit Codes
455. Chaining Commands
456. Chaining Commands with OR
457. Testing values
458. The `if` Statement in Bash
459. The `elif` Statement
460. Comparing Strings
461. Pattern Matching
462. Checking for Files
463. Numeric Tests
464. More Complex Conditions
465. Exercise (Material): Conditional File Download
466. Exercise (Overview): Conditional File Download
467. Solution (Material): Conditional File Download
468. Solution: Conditional File Download
469. How not to Test
470. The `case` Statement
Chapter 37: `while` loops - Utilize Iterative Control Flows
471. Intro
472. Materials
473. A first `while` Loop
474. `break` and `continue`
475. Reading a File Line by Line
476. Exercise (Material): Bulk Image Download
477. Exercise (Overview): Bulk Image Download
478. Solution (Material): Bulk Image Download
479. Solution: Bulk Image Download (Part 1)
480. Solution: Bulk Image Download (Part 2)
Chapter 38: `for` Loops - Traverse Data Sequences
481. Intro
482. Materials
483. Writing a first `for` Loop
484. Sequence expression and `for` Loops
485. Additional Expansions
486. Command Substitution and `for` Loops
487. Arithmetic Expressions and `for` Loops
Chapter 39: Project: Automated Thumbnail Generation (using
ImageMagick)
488. Intro
489. Materials
490. Installing ImageMagick
491. Querying Images
492. Converting Images
493. Working with Filenames
494. Exercise: Automated Thumbnail Generation
495. Solution (Materials): Automated Thumbnail Generation
496. Solution: Automated Thumbnail Generation
Chapter 40: User Interaction with `select`, `dialog`, and
zenity - Craft Interactive Menus
497. Intro
498. Materials
499. The `select` Construct
500. Example: `select` and `case` in Action
501. Installing the `dialog` Program
502. Creating a first Dialog (msgbox)
503. Creating a "yesno" Dialog
504. Creating a Text Input Dialog
505. Creating Menus
506. GUI dialoges with zenity
507. Exercise: Interactive Students Administration
508. Solution (Materials): Interactive Students
Administration
509. Solution: Interactive Students Administration
Chapter 41: Arguments In Bash - Process Command Line Input
within Scripts
510. Intro
511. Materials
512. Accepting Arguments
513. The `shift` command
514. `shift` and `while`
515. The `getopts` command
516. Accepting Multiple Options (`getopts`, `while`)
517. Accepting Options with Arguments
Chapter 42: Functions - Write Well-Structured Scripts
518. Intro
519. Creating a first Function
520. Variables within a Function
521. Getting Data into a Function
522. Getting Data out of a Function
523. Project (Overview): Trivia Game
524. Materials
525. Project (Exercise): Trivia Game (Part 1)
526. Project (Solution): Trivia Game (Part 2)
527. Project (Solution): Trivia Game (Part 3)
528. Project (Solution): Trivia Game (Part 4)
529. Project: Trivia Game (Part 5: random order)
530. Project: Trivia Game (Part 6: final touches)
Chapter 43: Arrays in Bash - Manage and Manipulate Data
Collections
531. Intro
532. Materials
533. Our first Array
534. Accessing an Array
535. Overwriting Array Elements
536. Array Operations
537. Copying an Array
538. `for` and `select`
539. Output of Program to Array
540. Output to Array (`readarray`)
541. How to check if an Array contains a specific Element
542. Associative Arrays
543. Exercise (Overview): Directory Storage Monitor
544. Solution (Material): Directory Storage Monitor
545. Solution: Directory Storage Monitor
546. Extra lecture (optional) (Enhancement): Directory
Storage Monitor
Chapter 44: Project: Build a Backup Script with Archiving and
Compression
547. Intro
548. Materials
549. Working with Archives
550. Compression (gz, bz2, xz)
551. Manually creating a .tar.bz2 file
552. Automatically creating a .tar.bz2 file
553. Exercise: Write a Backup Script
554. Exercise (Hints): Write a Backup Script (date)
555. Solution (Materials): Write a Backup Script
556. Solution: Write a Backup Script (Part 1)
557. Solution: Write a Backup Script (Part 2: adding `for`
Loop)
558. Solution: Write a Backup Script (Part 3: Error Handlung
I)
559. Solution: Write a Backup Script (Part 4: Error Handlung
II)
Chapter 45: Effective Data Filtering with `grep` and Regular
Expressions (regex)
560. Intro
561. A first search with `grep`
562. Most important options for `grep`
563. Data for the next Quiz
564. More options for `grep`
565. Combining multiple `grep` commands in a pipeline
566. Extracting specific information with `grep` and `cut`
567. Data for the next Quiz
568. Flavors of Regular Expressions
569. First Metacharacter: `. `
570. More Metacharacters: `^`, `$`, `\`
571. First Quantifier: `*`
572. Data for the next Quiz
573. Character Classes
574. Character Ranges
575. Negating Characters
576. Named Character Classes
577. Character Groups
578. From Basic Regular Expressions (BRE) to Extended
Regular Expressions (ERE)
579. Alternations
580. More Quantifiers: `?`, `+`, `{n}`, `{n,m}`, `{n,}`
581. Word Boundaries
582. How to use ERE features in BRE?
583. How to use ERE in Bash tests? (`=~`)
584. Pearl Compatible Regular Expressions (PCRE)
585. Extra lecture (optional): Lookaheads & Lookbehinds
(PCRE features)
586. Exercise: Log file from an Apache Webserver
587. Exercise (Overview): Analyze a Log File from an Apache
Webserver
588. Solution: Analyze a Log File from an Apache Webserver
Chapter 46: Reliable File Fetching: Download Files with `wget`
& Confirm Checksum Integrity
589. Intro
590. Link to the download of the next lecture
591. `wget` vs `curl`
592. CLI options for `wget`
593. Batch downloading with `wget`
594. Links to the downloads of the next lecture
595. Download a whole website with `wget`
596. Checksums
Chapter 47: The Depths of Bash - Dive into Advanced Bash
Features
597. Intro
598. Changing the Behavior of the `cd` Command
599. Advanced Globbing
600. Extended Globbing
601. Grouping Commands
602. Working with History in Bash
603. The `trap` Command
Chapter 48: Extra chapter (optional): Zsh (the Z Shell) -
Customize you CLI experience
604. Intro
605. Installation of Zsh
606. A first look into Zsh
607. Configuration Files for Zsh
608. Installing of Oh-My-Zsh
609. Extra lecture (optional): Different Behavior of `echo`
610. Zsh vs Bash, Expansions with Variables
611. Different Array Indexing
612. Extra lecture (optional): The Command `repeat`
613. Extra lecture (optional): Extended Globbing in Zsh
614. Extra lecture (optional): Zsh for Shell Scripts
Chapter 49: Final Words - Wrapping Up Your Linux Journey
615. Final Words
DATES
Published : 2023-09-05
Last Updated : 2026-02-05
If you fear the truth, don?t come to my well.