Mastering Linux: The Comprehensive Guide To The Command Line

Published 9/2023
MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
Language: English | Size: 54.50 GB | Duration: 71h 33m

Be in Demand and Unlock the Power of Linux: 70+ Hours of Hands-on Training. Step by Step, from Beginner to Expert!

What you'll learn
Industry Expert Guidance: Led by an experienced developer & instructor
70+ Hours of Depth: Complete coverage, from basics to expert
Real-Life Examples: Prioritizing genuine understanding
Hands-On Mastery: Deep dive into Bash CLI and Linux
Progressive Learning: Structured curriculum for all levels
Hands-on Challenges: Dive into real-world Linux projects
Have fun while learning: Many Exercises & interactive Quizzes

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

Description
Seeking a comprehensive and insightful course on Linux and the command line? Look no further. I'm a top-rated Udemy instructor with real-world experience, including full-stack development and two internships at Google. Crafted in English, this course combines deep industry insights with a proven teaching methodology.What sets this course apart? A staggering 70+ hours of video content, diving deep into every aspect of Linux and Bash scripting, offering unmatched depth and detail.Don't just learn Linux - understand it!Why settle for learning Linux when you can understand it? This course aims to instill a level of comprehension that sets you apart in the industry. Learn not just how, but why things work. Instead of merely following steps, you'll grasp the underlying principles, the reasons behind specific processes, and the intricate mechanics that make Linux a powerhouse. How is this course structured?Bash CLI Mastery:Our journey begins with an immersion into the Command Line Interface (CLI) with Bash. This fundamental part is all about acclimating you to the command line environment. Whether you're running simple commands or managing files, the CLI is a quintessential tool every Linux enthusiast should master. Through hands-on exercises and real-world scenarios, we ensure you're adept at using Bash effectively and efficiently.Diving Deep into Linux:The heart of this course lies in mastering Linux. Explore the intricate workings of Linux processes, user groups, and permissions. Grasp the nuances of package management across different platforms, and understand system facets like boot processes and mounts. By the end of this section, you'll navigate the Linux ecosystem with confidence and precision.Advanced Bash Scripting:Equipped with a foundational understanding, it's time to scale new heights. Delve into advanced Bash scripting where your skill set will evolve exponentially. From creating sophisticated scripts using loops and tests to leveraging APIs and JSON, this section is all about harnessing Bash's full potential. Real-world projects, such as manipulating images with 'imagemagick', ensure your learning is both theoretical and practical.The result:With this layered approach, we ensure a progressive learning curve, ensuring that beginners find a comfortable starting point, and advanced users are consistently challenged. Join us on this enlightening expedition!Why Choose This Course?Depth, Not Memorization: This course values understanding over rote learningIndustry-Relevant: Every lesson is designed with practical applications in mindComprehensive Scope: With over 70 hours of video, no topic is left untouchedProven Expertise: Benefit from instruction by one of Udemy's top-rated instructorsPractical Learning: Projects and assignments ensure your learning is application-basedPeer Support: Engage in active forums and get quick query resolutionsLifetime Access: Buy once, learn forever. Revisit materials anytime you need a refreshAct now, master Linux!Why wait? Enroll today and set yourself on a path to Linux mastery. This course offers you more than skills; it offers a competitive edge. Every element is crafted for your career advancement. Enroll now and transform your understanding of Linux and Bash scripting.

Overview
Section 1: ----- Part 1: INTRODUCTION & INSTALLATION -----

Lecture 1 Intro

Lecture 2 Getting the Most out of this Course

Lecture 3 What is Linux?

Lecture 4 What are Linux Distributions?

Lecture 5 Installing VirtualBox

Lecture 6 Installing Ubuntu[VirtualBox]

Lecture 7 For your convenience: Configuration Recap

Lecture 8 Configuration of Ubuntu[VirtualBox]

Lecture 9 Installing CentOS Stream[VirtualBox]

Lecture 10 Configuration of CentOS Stream[VirtualBox]

Lecture 11 For your convenience: Configuration Recap

Lecture 12 How to create a Snapshot?[VirtualBox]

Lecture 13 Outlook

Section 2:[Installation on MacOS with Apple Silicon Chips]

Lecture 14 Installing UTM

Lecture 15 Installing Ubuntu[UTM]

Lecture 16 Configuration of Ubuntu[UTM]

Lecture 17 Installing CentOS Stream[UTM]

Lecture 18 For your convenience: Configuration Recap

Lecture 19 Configuration of CentOS[UTM]

Lecture 20 For your convenience: Configuration Recap

Lecture 21 Outlook

Section 3: ----- Part 2: BASH CLI -----

Lecture 22 Bash CLI Intro

Section 4: First Steps in the Terminal

Lecture 23 Intro

Lecture 24 What is a Shell?

Lecture 25 A Short History of Shells

Lecture 26 Why Learning Bash is Essential

Lecture 27 Setting up your Terminal

Lecture 28 Outputting Text: the Command `echo`

Lecture 29 Displaying and Changing the Current Directory: the Commands `pwd` & `cd`

Lecture 30 Listing Content in Directories: the Command `ls`

Lecture 31 Path Types: Absolute Paths vs. Relative Paths

Lecture 32 Executing Multiple Commands using `;`

Lecture 33 Getting Terminal Help: `man` and `--help`

Section 5: First Steps with Linux

Lecture 34 Intro

Lecture 35 User Management Basics: System Accounts, Regular Users, Superusers

Lecture 36 Elevating Privileges: the Command `sudo`

Lecture 37 Optional[Troubleshooting]: When `sudo` does not work

Lecture 38 What is Package Management and how does it work?

Lecture 39 Updating and Installing Software in Ubuntu: apt

Lecture 40 Updating and Installing Software in CentOS Stream: dnf

Lecture 41 Extra lecture (optional)[MacOS]: How to use Bash in MacOS (Part 1)

Lecture 42 Extra lecture (optional)[MacOS]: How to use Bash in MacOS (Part 2)

Section 6: File Management (Part 1) - Organize Files & Directories

Lecture 43 Intro

Lecture 44 Creating Files and Directories: the Commands `touch` & `mkdir`

Lecture 45 Moving and Copying Files: the Commands `mv` & `cp`

Lecture 46 Deleting Files and Directories: the Commands `rm` & `rmdir`

Lecture 47 Exercise Intro: Website File Management

Lecture 48 Exercise: Website File Management

Lecture 49 Solution: Website File Management

Lecture 50 File Name Selection by Pattern Matching: Globbing with `*`

Lecture 51 Advanced Globbing Wildcards: `?`, `[0-9]`, `**`

Lecture 52 Pitfalls of Globbing: Avoiding Traps in Pattern Matching

Lecture 53 Exercise: Navigate a nested folder structure using Globbing

Lecture 54 Solution: Navigate a nested folder structure using Globbing

Lecture 55 Extra lecture (optional): Sophisticated File Searching: the Program `find`

Section 7: File Management (Part 2) - Handle Text Files

Lecture 56 Intro

Lecture 57 Viewing (Text) File Content: the Command `cat`

Lecture 58 Reading Large Text Files: the Command `less`

Lecture 59 Counting Words and Measuring Disk Usage: the Programs `wc` & `du`

Lecture 60 Text Editing in the Terminal: the Command-Line-Editor nano

Lecture 61 Exercise Intro: Analyze a Log File

Lecture 62 Exercise Materials: Analyze a Log File

Lecture 63 Solution: Analyze a Logfile

Section 8: Redirection - Manage Data Streams

Lecture 64 Intro

Lecture 65 Writing and Appending to (Text) Files: the Redirection Operators `>` & `>>`

Lecture 66 The Standard Streams: stdin, stdout, stderr

Lecture 67 Managing Error Messages: Redirecting stderr (and stdout)

Lecture 68 Redirecting stdout to stderr (Part 1)

Lecture 69 Redirecting stdout to stderr (Part 2)

Lecture 70 Redirecting stdin

Section 9: Pipes - Data Processing through Command Chaining

Lecture 71 Intro

Lecture 72 What is a Pipe (`|`)?

Lecture 73 Dual Output: the Utility `tee`

Lecture 74 Sorting and Removing Duplicates: the Commands `sort` and `uniq`

Lecture 75 Searching for Patterns in Text: the Utility `grep`

Lecture 76 Character Replacements and Reversal: the Utilities `tr` & `rev`

Lecture 77 Selective Extraction: the Program `cut`

Lecture 78 Text Substitution with the Stream Editor `sed`

Lecture 79 Exercise: Webserver Log File Analysis

Lecture 80 Exercise Material: Webserver Log File Analysis

Lecture 81 Solution: Webserver Log File Analysis

Section 10: Environment Variables - Manage your Shell Configuration

Lecture 82 Intro

Lecture 83 What are Environment Variables and how to access them?

Lecture 84 The Environment Variables HOME, PWD & USER

Lecture 85 Creating and Deleting Environment Variables: the Commands `export` & `unset`

Lecture 86 Efficient Command Execution: the variable PATH

Lecture 87 Extra lecture (optional): The File Hierarchy Standard

Lecture 88 Modifying the PATH variable

Lecture 89 Extra lecture (optional)[Python Script]: Creating Custom Executable Files

Lecture 90 Utilizing Environment Variables for Data Transfer into Programs (Python example)

Lecture 91 Retrieve the Default Shell: the Variable SHELL

Lecture 92 Storing Custom Shell Configurations: .bashrc and other Bash Startup Files

Lecture 93 Editing Bash Startup Files with the Command-Line Editor nano

Lecture 94 Command Shortcuts: Creating Aliases with the `alias` Command

Lecture 95 Adjusting Shell Behavior: the Command `set`

Lecture 96 Fine-Tuning Shell Behavior (Bash): the Command `shopt`

Section 11: Project - Create a Custom Bash Prompt

Lecture 97 Intro

Lecture 98 Customizing your Shell Prompt: the Variable PS1

Lecture 99 Terminal Color Control via Escape Sequences

Lecture 100 Bold Text in the Terminal:`infocmp` and additional Terminal Capabilitites

Lecture 101 Crash-course: Command Substitution `$(...)` in Bash

Lecture 102 Streamlining Terminal Control: the Program `tput`

Lecture 103 Important: PS1 fix for upcoming Exercise

Lecture 104 Exercise: Customize your Terminal Prompt

Lecture 105 Solution: Customize your Terminal Prompt

Section 12: Shell Expansions - How Commands are parsed

Lecture 106 Intro

Lecture 107 Filename Expansions: `*`& `?`

Lecture 108 Referencing the Home Directory: the Tilde expansion `~`

Lecture 109 Accessing and Manipulating Values: Variable and Parameter Expansions `${...}`

Lecture 110 Word splitting & the variable IFS

Lecture 111 Quoting Mechanisms: No Quotes vs. Single Quotes '...' vs. Double Quotes "..."

Lecture 112 Caution: Common Pitfalls in Shell Expansions

Lecture 113 Escaping: the Backslash character `\`

Lecture 114 Expanding Strings of Characters: the Brace Expansion `{...}`

Lecture 115 Leveraging Command Output: the Command Substitution `$(...)`

Lecture 116 Dynamic Input & Output: Process Substitution with `<(...)`& `>(...)`

Lecture 117 Recap

Section 13: ----- Part 3: LINUX -----

Lecture 118 Part 3: Linux Intro

Section 14: Files on Unix - The "Everything is a File" Concept

Lecture 119 Intro

Lecture 120 What is a File?

Lecture 121 Flexible File Referencing with Symlinks (Symbolic Links)

Lecture 122 Extra lecture (optional)[Windows]: Symlinks on Windows

Lecture 123 Referencing Inodes with Hardlinks

Lecture 124 Troubleshooting: The Inode Limit

Lecture 125 What is a Device?

Lecture 126 Examples of Pseudo-Devices: `/dev/null`, `/dev/random`, `/dev/urandom`,...

Lecture 127 System Insights: Files in the Folder `/proc`

Lecture 128 Filesystem Hierarchy Standard (Part 1): / (root), /bin, /boot, /dev, /etc

Lecture 129 Filesystem Hierarchy Standard (Part 2): /home, /lib, /media, /mnt, /opt

Lecture 130 Filesystem Hierarchy Standard (Part 3): /proc, /root, /run, /sbin, /srv, /sys

Lecture 131 Filesystem Hierarchy Standard (Part 4): /tmp, /usr, /var, /lost+found

Lecture 132 Streamlining Filesystem Structure: the Project usrmerge

Section 15: Linux User Management - Groups, Permissions & Access Control

Lecture 133 Intro

Lecture 134 Managing Users: The Roles of `/etc/passwd`, `/etc/shadow` & `/etc/groups`

Lecture 135 Creating and Securing New Users: `useradd` & `passwd`

Lecture 136 Extra lecture (optional): How Password Expiration works

Lecture 137 Change User Options: the Command `usermod`

Lecture 138 Deleting Users: the Command `userdel`

Lecture 139 How do Groups work?

Lecture 140 Add and Remove Group Members with `usermod`, `adduser`, `deluser`

Lecture 141 Creating & Modifying Custom Groups: the Command `groupadd`

Lecture 142 Switching Users: the Command `su`

Lecture 143 Elevating User Privileges with `sudo` (Deep Dive)

Lecture 144 Executing Commands as Different User with `sudo -U`

Lecture 145 Advanced `sudo` Configuration: the File `/etc/sudoers`

Lecture 146 Assigning & Changing File Permissions with `chmod` & `chown`

Lecture 147 Setting File Permissions Efficiently: `chmod` with Numerical Values

Lecture 148 Managing Permissions and Ownerships for Directories

Lecture 149 Setting Default File Permissions: the Command `umask`

Lecture 150 Securing Directories: Setting the Sticky Bit

Lecture 151 Advanced File Permissions: SUID (Set User ID) and SGID (Set Group ID)

Lecture 152 Best Practices for User Management

Section 16: Linux Processes - Orchestrate System Operations

Lecture 153 Intro

Lecture 154 Important[CentOS]: Note for CentOS Users

Lecture 155 What are Processes?

Lecture 156 Monitoring Processes: The `ps` Command

Lecture 157 Optional[MacOS]: Different Behavior of `ps` on MacOS

Lecture 158 Extra lecture (optional): BSD-style parameters (`ps aux`)

Lecture 159 Inspecting Context Switches: How Multitasking Works

Lecture 160 Controlling Process Priorities by Setting the Niceness

Lecture 161 Identifying Processes: Retrieving PIDs with `renice` and `pgrep`

Lecture 162 Influencing Processes with Signals

Lecture 163 Materials regarding the Upcoming Lessons

Lecture 164 Sending Signals with the `kill` command & the Interruption Signal SIGINT

Lecture 165 Terminating Processes Soft and Hard: the Signals SIGTERM vs SIGKILL

Lecture 166 Controlling Processes with the Signals SIGHUP, SIGSTOP and SIGCONT

Lecture 167 The `kill` Command vs the Program `/usr/bin/kill`

Lecture 168 Sending Signals to Multiple Processes: the `killall` Command

Lecture 169 Process Endings: Process Reaping, Orphan & Zombie Processes

Lecture 170 Overview of Process States

Lecture 171 Monitoring System Activity: the `top` Program

Lecture 172 Advanced `top` Usage (Deep Dive)

Lecture 173 Monitoring System Activity: the `htop` Program (Alternative to `top`)

Section 17: Job Control in Bash - Navigate Background and Foreground Operations

Lecture 174 Intro

Lecture 175 What Jobs are and how to Start your First Background Job (using `&`)

Lecture 176 Job Listing and Foregrounding: The `jobs` and `fg` Commands

Lecture 177 Suspending and Resuming Jobs with `fg`

Lecture 178 Terminating Jobs with `kill`

Lecture 179 Suspending Jobs with Output using `stty`

Lecture 180 Job Synchronization with the `wait` Command

Lecture 181 Keep Programs Running: the Command `nohup` vs `&`

Section 18: Package Management with `apt` & `dpkg`[Ubuntu]

Lecture 182 Intro

Lecture 183 dpkg

Lecture 184 apt

Lecture 185 Keeping a system up to date

Lecture 186 Autoremoving old dependencies

Lecture 187 The format of the sources.list file

Lecture 188 Custom repositories

Lecture 189 PPAs on Ubuntu

Lecture 190 Extra lecture (optional): debsums

Lecture 191 Dependencies

Lecture 192 Conflict resolution

Lecture 193 Reconfiguring packages

Lecture 194 snap

Section 19: Package Management with `dnf`[CentOS]

Lecture 195 Intro

Lecture 196 The rpm package format

Lecture 197 dnf

Lecture 198 Repositories ?

Lecture 199 What are dependencies?

Lecture 200 Weak dependencies

Lecture 201 Backward weak dependencies

Lecture 202 Automatic removing of dependencies

Lecture 203 Upgrades and downgrades

Lecture 204 Excluding packages from upgrades

Lecture 205 Automatic updates

Lecture 206 DNF modules

Lecture 207 DNF modules - part 2

Lecture 208 The repository epel-release

Lecture 209 How to deal with dependency issues

Lecture 210 Extra lecture (optional): snap

Section 20: The System Boot Process & Systemd - Understand the Startup Mechanisms

Lecture 211 Intro

Lecture 212 grub

Lecture 213 Crashcourse kernel

Lecture 214 Outlook systemd

Lecture 215 Controversy

Lecture 216 general structure systemd

Lecture 217 Manage an unit

Lecture 218 What is a cgroup?

Lecture 219 cgroup, firefox with 100MB memory

Lecture 220 Targets in systemd

Lecture 221 Enabling and disabling an unit

Lecture 222 Syntax of a systemd config file

Lecture 223 Editing Units (part 1)

Lecture 224 Editing units (part 2)

Lecture 225 Creating a custom unit

Lecture 226 Timers in systemd

Lecture 227 Timers in systemd (calendar)

Lecture 228 logging, journald, journalctl

Section 21: Volumes, Partitions & Mounts - Integrate and Manage Filesystems in Linux

Lecture 229 Intro

Lecture 230 Partitions

Lecture 231 Storage units, MiB vs MB

Lecture 232 Preparing the VM

Lecture 233 Creating a first partition

Lecture 234 Managing partions (CLI)

Lecture 235 Mounting drive automatically

Lecture 236 Mounting drive manually

Lecture 237 Mount options

Lecture 238 Mount options for exFAT

Lecture 239 Mounting with etc fstab

Lecture 240 Extra lecture (optional): Mounting a FTP drive

Lecture 241 Extra lecture (optional): Mounting a FTP drive (netrc)

Lecture 242 Extra lecture (optional): Mounting a FTP drive (fstab)

Lecture 243 Health monitoring (SMART)

Lecture 244 File system checks

Lecture 245 Automatic File system checks

Lecture 246 Extra lecture (optional): fixing broken fs

Lecture 247 Resizing filesystems (shrinking)

Lecture 248 Resizing filesystem (growing)

Section 22: Logical Volume Manager (LVM) - Handle Storage Dynamically

Lecture 249 Intro

Lecture 250 Preparing the VM

Lecture 251 Setup with LVM

Lecture 252 Creating Physical Volumes

Lecture 253 Creating a Volume Group

Lecture 254 Creating a Logical Volume

Lecture 255 Modifying Physical Volumes

Lecture 256 Changing Logical Volumes

Lecture 257 Delete Everything

Lecture 258 LVM on Boot

Lecture 259 Outlook

Section 23: Extra chapter (optional): Full Software Upgrade & Troubleshooting

Lecture 260 Intro

Lecture 261 Full System Upgrade

Lecture 262 Troubleshooting (Part 1)

Lecture 263 Troubleshooting (Part 2)

Lecture 264 Troubleshooting (Part 3)

Lecture 265 Outro

Section 24: Extra chapter (optional): Cron Jobs - Automate and Schedule Tasks

Lecture 266 Intro

Lecture 267 Different Cron Implementations

Lecture 268 How to open the crontab?

Lecture 269 The format of crontab

Lecture 270 Output to email[Ubuntu]

Lecture 271 Output to email[CentOS]

Lecture 272 The `flock` command

Lecture 273 The /etc/crontab File

Lecture 274 Anacron[Ubuntu]

Lecture 275 Anacron[CentOS]

Lecture 276 Best Practices for Cron Jobs

Section 25: Networking - Arrange and Manage Linux Communication Channels

Lecture 277 Overview: Networking

Lecture 278 What is the Internet?

Lecture 279 The `ip` command

Lecture 280 The tool Wireshark

Lecture 281 The Open Systems Interconnection (OSI) model

Lecture 282 The Physical Layer (OSI Layer 1)

Lecture 283 Influencing the Physical Layer

Lecture 284 The Data Link Layer (OSI Layer 2)

Lecture 285 What is a Switch?

Lecture 286 The Network Layer (OSI Layer 3)

Lecture 287 Subnets

Lecture 288 What are subnet masks?

Lecture 289 The Address Resolution Protocol (ARP)

Lecture 290 Manual IP adresses

Lecture 291 Adding Routes

Lecture 292 The Dynamic Host Configuration Protocol (DHCP)

Lecture 293 How does DHCP work on a Linux system (systemd)?

Lecture 294 How does DHCP work on a Linux system (NetworkManager)?

Lecture 295 The Program Ping

Lecture 296 How to use traceroute?

Lecture 297 How traceroute works

Lecture 298 The Transport Layer (OSI Layer 4)

Lecture 299 TCP & Ports

Lecture 300 Most Commonly Used Ports

Lecture 301 The TCP Handshake Process

Lecture 302 Port Scanning with nmap

Lecture 303 Advanced Port Scanning with nmap

Lecture 304 Extra lecture (optional): Network Address Translation (NAT)

Lecture 305 The Session Layer (OSI Layer 5)

Lecture 306 The Presentation Layer (OSI Layer 6)

Lecture 307 The Application Layer (OSI Layer 7)

Lecture 308 The Domain Name System (DNS) Protocol

Lecture 309 Types of DNS records

Lecture 310 Extra lecture (optional): DNS Query by Hand

Lecture 311 Potential Problems with DNS

Lecture 312 Changing the /etc/host file

Lecture 313 Hostnames and mDNS

Lecture 314 The Hypertext Transfer Protocol (HTTP)

Lecture 315 The contemporary Internet Protocol: IPv6

Section 26: SSH - Securely Connect to Remote Servers

Lecture 316 Intro

Lecture 317 What is the Secure Shell (SSH)?

Lecture 318 Networking (bridged)

Lecture 319 Networking (NAT)

Lecture 320 Our first SSH Connection

Lecture 321 Security tips (part 1, port)

Lecture 322 Security tips (part 1, port)[CentOS]

Lecture 323 Security tips (part 2, users)

Lecture 324 How to Not Lock Yourself Out

Lecture 325 Public Private Key

Lecture 326 Disabling Password Login

Lecture 327 How to Keep a Connection Open

Lecture 328 Fingerprints

Lecture 329 File transfers with SFTP

Lecture 330 The Utility Screen

Section 27: Project: Set up a Web Server

Lecture 331 Intro

Lecture 332 The LAMP Setup

Lecture 333 Installing LAMP[CentOS]

Lecture 334 Installing LAMP[Ubuntu]

Lecture 335 How to configure Apache?

Lecture 336 Configuration of Apache[CentOS]

Lecture 337 Adding a Port tohttpd[CentOS]

Lecture 338 Configuration of Apache2[Ubuntu]

Lecture 339 How does a VirtualHost work?

Lecture 340 Creating a VirtualHost[CentOS]

Lecture 341 Creating a VirtualHost[Ubuntu]

Lecture 342 How do the Log Files work?

Lecture 343 PHP[CentOS]

Lecture 344 PHP[Ubuntu]

Lecture 345 Setting up MySQL

Lecture 346 Creating a MySQL Admin User

Lecture 347 Installing phpmyadmin[CentOS]

Lecture 348 Installing phpmyadmin[Ubuntu]

Lecture 349 Preparing the DB for WordPress

Lecture 350 Installation of WordPress

Lecture 351 How to Override Configuration via htaccess

Lecture 352 How to Password Protect a Directory

Lecture 353 Access phpmyadmin through Tunnel

Section 28: Extra chapter (optional): Firewall - Control Network Traffic

Lecture 354 Intro

Lecture 355 Why we need a Firewall

Lecture 356 Why we are not learning iptables

Lecture 357 The Architecture of firewalld

Lecture 358 Installing firewalld on Ubuntu

Lecture 359 What are Services in firewalld?

Lecture 360 Opening and Closing Services

Lecture 361 Zones in firewalld

Lecture 362 Outlook firewalld

Section 29: SELinux (Security Enhanced Linux) - Enforce Robust Access Control Policies

Lecture 363 Intro

Lecture 364 Discretionary Access Control

Lecture 365 The Problem with Discretionary Access Control

Lecture 366 Mandatory Access Control

Lecture 367 Enabling and Disabling SELinux

Lecture 368 File Contexts in SELinux

Lecture 369 How SELinux Protects you

Lecture 370 Changing File Context (`chcon`, `restorecon`)

Lecture 371 Setting Default Contexts (`semanage fcontext`)

Lecture 372 Security Attributes of Processes

Lecture 373 A quick look at the SELinux Policy

Lecture 374 Targeted Policy and how Processes are Started

Lecture 375 SELinux Booleans

Lecture 376 How to fix Policy Violations

Lecture 377 Managing Ports

Lecture 378 Disabling SELinux during Boot

Lecture 379 Summary and Outlook

Section 30: Linux Distributions - Explore the Landscape from Red Hat to Arch Linux

Lecture 380 Intro

Lecture 381 The Red Hat family: Fedora, CentOS Stream, Red Hat Enterprise Linux

Lecture 382 The extended Red Hat family: Rocky Linux, AlmaLinux, Oracle Linux

Lecture 383 The Debian family: Debian, Ubuntu, Kali Linux, Raspberry Pi OS, Linux Mint

Lecture 384 Ubuntu Linux and its variants: Ubuntu Server, Kubuntu, Xubuntu, Lubuntu

Lecture 385 The SUSE family: SUSE Linux Enterprise, openSUSE: Leap & Tumbleweed

Lecture 386 Arch Linux

Lecture 387 Gentoo Linux

Lecture 388 How to choose a Linux Distribution?

Section 31: ----- Part 4: BASH SCRIPTING -----

Lecture 389 Part 4: Bash Scripting Intro

Section 32: Bash Scripting Basics (Part 1) - Leverage Variables for Dynamic Scripts

Lecture 390 Intro

Lecture 391 Our first Bash Script

Lecture 392 What is a Shebang?

Lecture 393 Comments in Bash

Lecture 394 Variables in Bash

Lecture 395 Bash Variables vs. Environment Variables

Lecture 396 How to not declare a Variable

Lecture 397 The `declare` command

Lecture 398 Unsetting Variables

Lecture 399 Reading Input (`read`)

Lecture 400 Advanced `read` Usage

Lecture 401 Reading the Contents of a File

Lecture 402 Let's Create a Program

Lecture 403 Exercise (Overview): System Info Script

Lecture 404 Solution: System Info Script

Section 33: Bash Scripting Basics (Part 2) - Build Robust Scripts

Lecture 405 Intro

Lecture 406 Pipe vs Process Substitution

Lecture 407 Splitting a Script into Multiple Files

Lecture 408 Making a Script accessible through PATH

Lecture 409 Best Practices for Shell Scripts

Lecture 410 Paths in Shell Scripts

Lecture 411 The `shellcheck` Program

Lecture 412 Writing Shell Scripts with Visual Studio Code

Section 34: Numeric Variables & Arithmetic Operations - Work with Numerical Data

Lecture 413 Intro

Lecture 414 Basic Math in Bash

Lecture 415 Integer Variables

Lecture 416 Read ints in Bash

Lecture 417 How to use Decimals

Lecture 418 Extra lecture (optional): `awk`

Section 35: Access External Data - Retrieve JSON Data from APIs

Lecture 419 Intro

Lecture 420 How an HTTP Request works

Lecture 421[Windows]: Install git Bash Environment on Windows

Lecture 422 First steps with `curl`

Lecture 423 Extra lecture (optional): How the Download Bar from `curl` works

Lecture 424 What is JSON?

Lecture 425 The Program jq

Lecture 426 Exercise (Materials): Fetch Weather Data

Lecture 427 Exercise (Overview): Fetch Weather Data

Lecture 428 Solution (Materials): Fetch Weather Data

Lecture 429 Solution: Fetch Weather Data (Part 1; API)

Lecture 430 Solution: Fetch Weather Data (Part 2; JSON)

Section 36: Tests & the `if` Clause - Implement Logical Evaluations & Conditional Logic

Lecture 431 Intro

Lecture 432 Exit Codes

Lecture 433 Chaining Commands

Lecture 434 Chaining Commands with OR

Lecture 435 Testing values

Lecture 436 The `if` Statement in Bash

Lecture 437 The `elif` Statement

Lecture 438 Comparing Strings

Lecture 439 Pattern Matching

Lecture 440 Checking for Files

Lecture 441 Numeric Tests

Lecture 442 More Complex Conditions

Lecture 443 Exercise (Material): Conditional File Download

Lecture 444 Exercise (Overview): Conditional File Download

Lecture 445 Solution (Material): Conditional File Download

Lecture 446 Solution: Conditional File Download

Lecture 447 How not to Test

Lecture 448 The `case` Statement

Section 37: `while` loops - Utilize Iterative Control Flows

Lecture 449 Intro

Lecture 450 Materials

Lecture 451 A first `while` Loop

Lecture 452 `break` and `continue`

Lecture 453 Reading a File Line by Line

Lecture 454 Exercise (Material): Bulk Image Download

Lecture 455 Exercise (Overview): Bulk Image Download

Lecture 456 Solution (Material): Bulk Image Download

Lecture 457 Solution: Bulk Image Download (Part 1)

Lecture 458 Solution: Bulk Image Download (Part 2)

Section 38: `for` Loops - Traverse Data Sequences

Lecture 459 Intro

Lecture 460 Materials

Lecture 461 Writing a first `for` Loop

Lecture 462 Sequence expression and `for` Loops

Lecture 463 Additional Expansions

Lecture 464 Command Substitution and `for` Loops

Lecture 465 Arithmetic Expressions and `for` Loops

Section 39: Project: Automated Thumbnail Generation (using ImageMagick)

Lecture 466 Intro

Lecture 467 Materials

Lecture 468 Installing ImageMagick

Lecture 469 Querying Images

Lecture 470 Converting Images

Lecture 471 Working with Filenames

Lecture 472 Exercise: Automated Thumbnail Generation

Lecture 473 Solution (Materials): Automated Thumbnail Generation

Lecture 474 Solution: Automated Thumbnail Generation

Section 40: User Interaction with `select`, `dialog`, and zenity - Craft Interactive Menus

Lecture 475 Intro

Lecture 476 Materials

Lecture 477 The `select` Construct

Lecture 478 Example: `select` and `case` in Action

Lecture 479 Installing the `dialog` Program

Lecture 480 Creating a first Dialog (msgbox)

Lecture 481 Creating a "yesno" Dialog

Lecture 482 Creating a Text Input Dialog

Lecture 483 Creating Menus

Lecture 484 GUI dialoges with zenity

Lecture 485 Exercise: Interactive Students Administration

Lecture 486 Solution (Materials): Interactive Students Administration

Lecture 487 Solution: Interactive Students Administration

Section 41: Arguments In Bash - Process Command Line Input within Scripts

Lecture 488 Intro

Lecture 489 Materials

Lecture 490 Accepting Arguments

Lecture 491 The `shift` command

Lecture 492 `shift` and `while`

Lecture 493 The `getopts` command

Lecture 494 Accepting Multiple Options (`getopts`, `while`)

Lecture 495 Accepting Options with Arguments

Section 42: Functions - Write Well-Structured Scripts

Lecture 496 Intro

Lecture 497 Creating a first Function

Lecture 498 Variables within a Function

Lecture 499 Getting Data into a Function

Lecture 500 Getting Data out of a Function

Lecture 501 Project (Overview): Trivia Game

Lecture 502 Materials

Lecture 503 Project (Exercise): Trivia Game (Part 1)

Lecture 504 Project (Solution): Trivia Game (Part 2)

Lecture 505 Project (Solution): Trivia Game (Part 3)

Lecture 506 Project (Solution): Trivia Game (Part 4)

Lecture 507 Project: Trivia Game (Part 5: random order)

Lecture 508 Project: Trivia Game (Part 6: final touches)

Section 43: Arrays in Bash - Manage and Manipulate Data Collections

Lecture 509 Intro

Beginners: Dive into the essentials of Linux and Bash, with no prior knowledge required. Start your journey with confidence, guided by an experienced instructor,Intermediate Users: Elevate your existing knowledge, patching any gaps and solidifying your understanding. Delve deeper into the nuances and intricacies of Linux operations,Advanced Professionals: Challenge yourself with sophisticated Bash scripting exercises and explore the high-level functionalities of Linux, ensuring you remain at the forefront of your field,Web Developers & IT Specialists: Gain invaluable skills that seamlessly integrate into your professional toolkit, making you a more versatile and effective tech professional,Enthusiasts & Hobbyists: Satiate your curiosity, turning passion into prowess with a structured learning path, all while indulging in a subject you love

Buy Premium Account From My Download Links & Get Fastest Speed.