English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 162 Lessons (11h 47m) | 2.41 GB
Become a Linux power user!
Learn the ins and outs of Linux Internals and discover what makes Linux the most powerful operating system
Get under the hood and understand how Linux really works
Perform in-depth practical investigations of key Linux functionalities
Linux Under the Hood offers an extensive exploration of how Linux functions, allowing you to fully harness its capabilities. Familiarizing yourself with Linux internals will allow you to surpass mere commands and gain valuable insights to optimize your use of Linux.
The first module dives into a deeper understanding of Linux architecture; you will learn about the inner workings of key Linux components like the kernel, systemd, and the Linux boot procedure. The following module will focus on storage and filesystems, encompassing local devices as well as cloud and datacenter storage solutions. Next, we will cover core components, including memory, processes, and the intricacies of command execution. Finally, we will explore Linux’s evolution into a container-based platform.
Each lesson concludes with a real-world scenario, where Sander demonstrates the practical implementation of various features explained in the lesson videos.
Course requirement:
- Learners are expected to have basic working knowledge of the Linux operating system.
- Learners should prepare one virtual or physical machine with any Linux distribution; hardware specs are not important.
- To make it easy to follow along with the instructor, it is recommended (but not required) to install either the latest version of Ubuntu LTS (either workstation or server edition) or the latest CentOS Stream or equivalent.
Who Should Take This Course:
- The target audience for this course consists of people that have used Linux for a while and who want to know what it really is doing.
- The typical primary audience consists of system administrators.
- The secondary audience consists of operating system students and others who want to know how Linux works.
Table of Contents
Introduction
Linux Under the Hood Introduction
Linux Under the Hood Introduction
Lesson 1 Core Linux Elements
Learning objectives
System Space and User Space, and How They are Related
The Role of the Kernel
Why the Root User is Unrestricted
Drivers, Kernel Modules, and Device Files
Glibc
The Shell
File Descriptors
Real-world Scenario Understanding the Root User
Lesson 2 The Linux Boot Procedure
Learning objectives
The Boot Procedure from Firmware to Shell
System Firmware UEFI and BIOS
Managing UEFI Booting
Bootloaders
Where GRUB is Stored
Configuring GRUB2
Understanding and Modifying Initramfs
Service Managers
Booting Cloud Linux Instances
Accessing an Early Boot Shell
Real-world Scenario Recovering From a Lost MBR
Lesson 3 Looking Closer at the Kernel
Learning objectives
Why Compiling Kernels isn’t Necessary Anymore
Kernel Generic Interfaces
Managing and Tuning Kernel Modules
The proc Pseudo Filesystem
Using proc to get Detailed System Information
Reading Process Information in proc
Tuning the Kernel through procsys
Testing Critical Features with sysrq
Using Watchdogs
eBPF
Real-world Scenario Automatically Recovering from System Hangs
Lesson 4 Systemd Taking Over
Learning objectives
Manually Starting Systemd
Systemd Unit Files
Tweaking Unit Files
Mounting Filesystems with Systemd
Using Sockets
Scheduling Processes with Timers
Analyzing Systemd Performance
Advanced Dependency Handling
Managing Resource Allocation – Part 1
Managing Resource Allocation – Part 2
Managing Resource Allocation – Part 3
Creating Custom Units
Creating Custom Targets
Running User Processes in Systemd
Real-world Scenario Booting without etcfstab
Lesson 5 Hardware Handling
Learning objectives
Understanding Device Nodes
Initializing Devices Automatically or Manually
Analyzing sysfs
Systemd-udevd
Creating Udev Rules
Real-world Scenario Denying Unauthorized Devices
Lesson 6 Storage Devices
Learning objectives
Linux Storage Devices
Partitions MBR and GPT
Managing Partitions
Images and ISO Files
Understanding Flexible Storage Solutions
Managing LVM Logical Volumes
Using LVM Features
Device Mapper
Manually Creating Device Mapper Storage
LVM and VDO
Stratis
Creating Encrypted Devices
Booting from Encrypted Devices
Real-world Scenario Creating a Hidden Storage Device
Lesson 7 Filesystems
Learning objectives
Filesystems and the VFS
About POSIX and non-POSIX Filesystems
Linux Filesystem Components
Inodes and Block Allocation
Sparse Files
FUSE Filesystems
Next-generation Filesystems
Running ZFS on Linux
Running Btrfs
Using the Ext Filesystem Debugger
Managing XFS IDs
Real-world Scenario Exploring Cool Filsystem Tools
Lesson 8 Cloud and Datacenter Storage
Learning objectives
Storage Challenges in Cloud and Datacenter
Working with SSD Media
Understanding iSCSI
Configuring iSCSI Storage
Connecting the Initiator
Object Storage
Configuring a Ceph Cluster
Configuring a Ceph Client
Real-world Scenario Ceph in Kubernetes
Lesson 9 Memory Management
Learning objectives
Linux Memory Allocation Virtual vs. Physical Memory
Cache
Active and Inactive Memory
The Need to Swap
Configuring and Monitoring Swap Space
Managing Huge Pages
Managing Dirty Cache
Out of Memory (OOM) and Dealing with it
Analyzing Kernel Memory
Real-world Scenario Optimizing Memory Usage
Lesson 10 Processes
Learning objectives
How a Process is Created
Processes and Threads
Killing a Zombie
Priorities, Schedulers, and Nice Values
Inter-process Communication, Sockets, Pipes, and More
Communicating on the D-Bus Message Interface
Monitoring IPC Usage
Real-world Scenario Cgroups and Priorities
Lesson 11 Linux Commands and How They Work
Learning objectives
Exploring What Happens When Commands are Executed
System Space and User Space
Understanding System Calls
How Processes get Access to System Calls
How Process Memory is Organized
Creating Processes
Allocating Memory
Accessing Libraries
Analyzing Library Usage
Real-world Scenario Using exec for Troubleshooting
Lesson 12 Networking
Learning objectives
Linux Network Device Names
The OSI Model
Transforming Data into Packets
Analyzing Packet Headers
IPv4 and IPv6
How Linux Chooses a Network Interface
Analyzing and Optimizing Networking
Bonding and Teaming
Network Bridge Devices
Real-world Scenario Scanning Packets for Security
Lesson 13 Containers are Linux, Linux is Containers
Learning objectives
Running an Application on Linux
Running Applications in a Chroot Jail
Managing Linux Process Resource Allocation
Using unshare to run Namespaced Processes
Running Linux Applications with Namespaces and Cgroups
From Restricted Linux Applications to Containers
Container Runtimes
Systemd Containers
Containers and the Future of Linux
Real-world Scenario Running Pure Linux Containers
Lesson 14 The Code Behind Linux
Learning objectives
The C Programming Language
Working Together in Git
From Git Project to Linux Distributions
C Programs From Source Code to Binary
C and Libraries
Compiling a C Program from a Makefile
Real-world Scenario Writing Your own Zombie
Module 1 Linux Architecture
Module introduction
Module 2 Storage and Filesystems
Module introduction
Module 3 Core Linux Components
Module introduction
Module 4 Key Linux Components
Module introduction
Summary
Linux Under the Hood Summary
Resolve the captcha to access the links!