Exploring Linux Internals: Advanced Insights and Practical Applications

11h 49mIntermediate2024-10-18

Authors

Pearson

Sander van Vugt

Course details

Familiarizing yourself with Linux internals will allow you to surpass mere commands and gain valuable insights to optimize your use of Linux. This course offers an extensive exploration of how Linux functions, allowing you to fully harness its capabilities. 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.

The course starts with an exploration of the Linux architecture, examining the inner workings of key Linux components like the kernel, systemd, and the Linux boot procedure. Next, learn about the storage and filesystems, encompassing local devices as well as cloud and datacenter storage solutions. Core components, including memory, processes, and the intricacies of command execution are covered next. Finally, explore Linux's evolution into a container-based platform.

Skills covered

LinuxServer AdministrationNetwork and System AdministrationOpen SourceOne-Off

Concepts

0. Introduction

01 - Linux under the hood - Introduction

Lesson 1 - Core Linux Elements

02 - Module 1 - Linux architecture introduction
03 - Learning objectives
04 - System space and user space, and how they are related
05 - The role of the kernel
06 - Why the root user is unrestricted
07 - Drivers, kernel modules, and device files
08 - Glibc
09 - The shell
10 - File descriptors
11 - Real-world scenario - Understanding the root user

Lesson 2 - The Linux Boot Procedure

12 - Learning objectives
13 - The boot procedure from firmware to shell
14 - System firmware - UEFI and BIOS
15 - Managing UEFI booting
16 - Bootloaders
17 - Where GRUB is stored
18 - Configuring GRUB2
19 - Understanding and modifying initramfs
20 - Service managers
21 - Booting cloud Linux instances
22 - Accessing an early boot shell
23 - Real-world scenario - Recovering from a lost MBR

Lesson 3 - Looking Closer at the Kernel

24 - Learning objectives
25 - Why compiling kernels isn t necessary anymore
26 - Kernel generic interfaces
27 - Managing and tuning kernel modules
28 - The proc pseudo filesystem
29 - Using proc to get detailed system information
30 - Reading process information in proc
31 - Tuning the kernel through proc sys
32 - Testing critical features with sysrq
33 - Using watchdogs
34 - eBPF
35 - Real-world scenario - Automatically recovering from system hangs

Lesson 4 - Systemd Taking Over

36 - Learning objectives
37 - Manually starting systemd
38 - Systemd unit files
39 - Tweaking unit files
40 - Mounting filesystems with systemd
41 - Using sockets
42 - Scheduling processes with timers
43 - Analyzing systemd performance
44 - Advanced dependency handling
45 - Managing resource allocation, part 1
46 - Managing resource allocation, part 2
47 - Managing resource allocation, part 3
48 - Creating custom units
49 - Creating custom targets
50 - Running user processes in systemd
51 - Real-world scenario - Booting without etc fstab

Lesson 5 - Hardware Handling

52 - Learning objectives
53 - Understanding device nodes
54 - Initializing devices automatically or manually
55 - Analyzing sysfs
56 - Systemd-udevd
57 - Creating udev rules
58 - Real-world scenario - Denying unauthorized devices

Lesson 6 - Storage Devices

59 - Module 2 - Storage and filesystems introduction
60 - Learning objectives
61 - Linux storage devices
62 - Partitions - MBR and GPT
63 - Managing partitions
64 - Images and ISO files
65 - Understanding flexible storage solutions
66 - Managing LVM logical volumes
67 - Using LVM features
68 - Device mapper
69 - Manually creating device mapper storage
70 - LVM and VDO
71 - Stratis
72 - Creating encrypted devices
73 - Booting from encrypted devices
74 - Real-world scenario - Creating a hidden storage device

Lesson 7 - Filesystems

75 - Learning objectives
76 - Filesystems and the VFS
77 - About POSIX and non-POSIX filesystems
78 - Linux filesystem components
79 - Inodes and block allocation
80 - Sparse files
81 - FUSE filesystems
82 - Next-generation filesystems
83 - Running ZFS on Linux
84 - Running Btrfs
85 - Using the Ext filesystem debugger
86 - Managing XFS IDs
87 - Real-world scenario - Exploring cool filesystem tools

Lesson 8 - Cloud and Datacenter Storage

88 - Learning objectives
89 - Storage challenges in cloud and datacenter
90 - Working with SSD media
91 - Understanding iSCSI
92 - Configuring iSCSI storage
93 - Connecting the initiator
94 - Object storage
95 - Configuring a Ceph cluster
96 - Configuring a Ceph client
97 - Real-world scenario - Ceph in Kubernetes

Lesson 9 - Memory Management

98 - Module 3 - Core Linux components introduction
99 - Learning objectives
100 - Linux memory allocation - Virtual vs. physical memory
101 - Cache
102 - Active and inactive memory
103 - The need to swap
104 - Configuring and monitoring swap space
105 - Managing huge pages
106 - Managing dirty cache
107 - Out of memory (OOM) and dealing with it
108 - Analyzing kernel memory
109 - Real-world scenario - Optimizing memory usage

Lesson 10 - Processes

110 - Learning objectives
111 - How a process is created
112 - Processes and threads
113 - Killing a zombie
114 - Priorities, schedulers, and nice values
115 - Inter-process communication, sockets, pipes, and more
116 - Communicating on the D-Bus message interface
117 - Monitoring IPC usage
118 - Real-world scenario - Cgroups and priorities

Lesson 11 - Linux Commands and How They Work

119 - Learning objectives
120 - Exploring what happens when commands are executed
121 - System space and user space
122 - Understanding system calls
123 - How processes get access to system calls
124 - How process memory is organized
125 - Creating processes
126 - Allocating memory
127 - Accessing libraries
128 - Analyzing library usage
129 - Real-world scenario - Using exec for troubleshooting

Lesson 12 - Networking

130 - Learning objectives
131 - Linux network device names
132 - The OSI model
133 - Transforming data into packets
134 - Analyzing packet headers
135 - IPv4 and IPv6
136 - How Linux chooses a network interface
137 - Analyzing and optimizing networking
138 - Bonding and teaming
139 - Network bridge devices
140 - Real-world scenario - Scanning packets for security

Lesson 13 - Containers are Linux, Linux is Containers

141 - Module 4 - Key Linux components introduction
142 - Learning objectives
143 - Running an application on Linux
144 - Running applications in a chroot jail
145 - Managing Linux process resource allocation
146 - Using unshare to run namespaced processes
147 - Running Linux applications with namespaces and cgroups
148 - From restricted Linux applications to containers
149 - Container runtimes
150 - Systemd containers
151 - Containers and the future of Linux
152 - Real-world scenario - Running pure Linux containers

Lesson 14 - The Code Behind Linux

153 - Learning objectives
154 - The C programming language
155 - Working together in Git
156 - From Git project to Linux distributions
157 - C programs - From source code to binary
158 - C and libraries
159 - Compiling a C program from a makefile
160 - Real-world scenario - Writing your own zombie

Summary

161 - Linux under the hood - Summary