Linux Mastery: LPIC-1 (102-500) Ultimate Certification Prep

Configure a Linux hostname to uniquely identify a system on the network. Use temporary changes with hostname and permanent changes with hostnamectl or editing /etc/hostname and updating /etc/hosts.

Master IPv4 concepts, including static and dynamic addresses, dot decimal notation, and subnet masks, then learn how to determine network and host portions and use ping and traceroute for connectivity.

Explore the ip command for managing interfaces, addresses, and routes, using ip link show, ip address show, and ip route with practical examples like ip addr add.

Conduct a practical lab that uses ip addr, ip route, and ip link to inspect interfaces, addresses, routing, and sockets, then ping, tracepath, and verify router reachability.

Configure networks with nmcli, the Network Manager command line interface, to view, create, modify, and activate connections and manage devices, including DHCP and static configurations.

Validate linux network configuration by gathering interface info with ip link and ip addr, verify mac and ip addresses, test connectivity with ping and traceroute, and inspect sockets with ss.

Back up your connection before changing network settings. Learn to edit network configurations with nmcli and ifcfg files, set IP v4 addresses, prefix, gateway, and DNS, then reload and verify.

configure a server with two static ipv4 addresses on a single interface using nmcli, set one to auto start, and map 10.0.1.1 as private in /etc/hosts, then reboot and test.

Understand Linux user accounts and security boundaries, including uid and usernames, and passwords. Learn to use id, ls, and ps to view user, file, and process ownership.

Learn how to securely manage superuser access in Red Hat Linux using su and sudo, switch to other users, and audit elevated commands with sudo logs.

Configure sudo by editing /etc/sudoers and the /etc/sudoers.d directory to grant user or group full access, including no-password options and notes on sudo versus sudo -i.

Practice gaining superuser access with sudo, switch to root via sudo su and sudo su dash, compare non-login and login shells, and create a new sudo user operator one.

Create, modify, and delete users with useradd, usermod, and userdel; manage home directories and groups; set passwords; and understand uid ranges and security implications.

Practice creating, modifying, and deleting Linux user accounts using useradd, usermod, and userdel, assigning passwords with passwd, adding users to groups, and verifying entries in /etc/passwd.

Master local group management using groupadd, groupdel, and groupmod to set gid, create system groups, rename groups, and adjust primary and supplementary user memberships with usermod.

Practice creating local supplementary groups, add operator and admin users with groupadd and usermod -aG, verify with id and /etc/group, and configure sudo privileges for admin members.

Learn how Linux stores encrypted passwords in /etc/shadow with salt and a hash, and how to manage password aging, expiration, and account access using chage and related commands.

Practice managing user passwords in Linux by forcing a first-login password change, enforcing a 90-day password age, expiring accounts after 180 days, and applying a global 180-day policy.

Learn to manage local users and groups by creating a consultants group (gid 40000) with supplementary membership and granting sudo rights. Enforce 90-day expiration and 15-day passwords with first-login changes.

Explore Linux file system permissions, focusing on owner, group, and others with read, write, and execute rights, and learn how the most specific permissions prevail.

Master changing file permissions with chmod using symbolic and numeric methods, including u, g, o, a, read, write, execute, and recursive options for directories.

Change file and directory ownership with the chown command, including recursive -R changes. Use the owner:group syntax and avoid the dot syntax.

Learn to configure Linux file permissions to enable a collaborative group directory. Create the directory, set group ownership to consultants, grant group write, and restrict others.

Control default permissions for new files and directories and understand special permissions (setuid, setgid, sticky) and how umask tunes initial access.

Master the use of umask and setgid to control default permissions in a shared directory, creating files owned by the operators group and verifying permissions through hands-on commands.

Configure file access for a group by creating the home tech docs directory, setting setgid, applying group write permissions, and enforcing a global unmask for new files.

List and monitor Linux processes with the ps command, understand process states such as running, sleeping, and zombie, and learn to control and terminate batch job processes.

Master bash job control to manage foreground and background processes, pipelines, and sessions, using fg, bg, and ctrl+z, while monitoring with ps and terminal ttys.

Gain hands-on experience with job control to suspend and restart foreground and background processes using fg, bg, and jobs, while monitoring output with tail.

Learn to kill and manage processes using signals, such as hup, int, quit, and sigkill, and use kill, pkill, pgrep, and process trees to control sessions and daemon processes.

Explore monitoring process activity in Linux by understanding load average, what the kernel considers, and using uptime, lscpu, and top to interpret CPU and IO load.

Practice monitoring and managing Linux processes with top, create cpu-load scripts, observe cpu usage, manage processes with ps, jobs, and pkill, and save top configurations.

Learn to control and monitor systemd managed services and daemons, using systemctl to list, check status, enable, and start units, including service, socket, and path units.

Learn to manage system services with systemctl: list service and socket units, inspect cron and sshd status, start/stop/restart/reload services, enable at boot, mask conflicting services, and inspect dependencies.

Master secure remote administration with OpenSSH by configuring key-based authentication, restricting root logins, and disabling password-based access across Linux systems; learn to access command lines and customize the OpenSSH service.

Configure ssh key-based authentication to log in passwordless by generating private and public keys, securing them with a passphrase, copying the public key to servers, and using ssh-agent and ssh-add.

Configure OpenSSH by editing sshd_config to prohibit direct root logins and password authentication, enable key-based login, and reload sshd to apply changes.

Learn to configure syslog by understanding facilities and priorities (0–7), and apply rc log rules. Use log rotate, tail -f, and logger to monitor and route messages.

Learn to locate and interpret system journal entries to troubleshoot problems using journalctl, filtering by priority, time, or unit and examining fields like _pid and _uid.

Configure the system journal to persist across reboots by setting storage to persistent in the etc. systemd journal conf file and restarting the systemd journal service, ensuring /var/log/journal exists.

Maintain accurate system time by configuring NTP synchronization and correct time zones to ensure reliable timestamps in system logs and journals.

update the server time zone to europe paris, configure a log file for authentication failures, and display the previous 30 minutes of logs with journalctl and logger.

Archive and transfer files with tar, using gzip, bzip2, or xz compression, and learn create, extract, and list options, preserving permissions and SSH-based synchronization with a remote server.

Transfer files securely between systems using scp and sftp over ssh, with key-based or password authentication and remote path syntax like user@host:/path.

Schedule deferred tasks with the at package and atd daemon, using add and timespec to run jobs now or later, and manage queues, crontab, and systemd timers.

Learn to schedule recurring user jobs with crontab on Red Hat Linux. Use per-user and system-wide cron settings, handle output, and manage with crontab L, E, and R.

Schedule recurring system jobs with systemwide crontab files in /etc and /etc/cron.d, including daily, weekly, and monthly scripts, and consider systemd timer units with systemctl daemon reload after changes.

Schedule and monitor daily recurring system jobs to log the number of active users, and configure systemd timer and sysstat to collect system activity data every two minutes.

Enable and configure systemd tmpfiles timers to manage temporary files, creating volatile run and tmp directories and purging unused data on boot and during operation.

Configure systemd tmpfiles to purge unused files in /tmp after five days, and to purge /run/momentary after 30 seconds, with permissions 1777 and 0700 and root ownership.

Apply tuned daemon tuning profiles to optimize system performance through static tuning. Dynamically adjust kernel parameters and process priorities with nice and renice for storage, CPU, and network workloads.

Adjust process scheduling across single and multi-core systems using time slicing and sched policies, and manage nice values from -20 to 19 with top, ps, nice, and renice.

Practice changing process scheduling by using the nice command to adjust priorities, spawn multiple sha1sum instances across cpu cores, and monitor with ps, pgrep, and jobs.

Interpret and set access control lists (acl) on files to grant permissions to named users and groups, view with getfacl, and manage inheritance, default acl, and mask.

Manage file access with acls using setfacl and getfacl, adding, modifying, and deleting user, group, and other entries. Apply changes recursively, manage masks, and work with default acl inheritance.

Grant the consultants group read, write, and execute permissions on shares/content recursively, while denying consultant one, and set default ACLs for new files.

Learn to create and manage storage devices, partitions, file systems (zfs, ext4), and swap spaces from the command line, using parted for MBR and GPT, and configure mounts with fstab.

Add a 1 gb zfs partition on sdb with an ms-dos label starting at sector 2048, format it, and configure persistent mounting at /archive via fstab, then reboot to verify.

Learn to create gpt partitions on new disks, format with zfs, persistently mount at backup, and configure swap spaces activated at boot for robust storage management.

Master LVM basics: create physical volumes, form volume groups, allocate logical volumes, format with a file system or swap, and non-destructively extend logical volumes.

Extend and shrink volume groups by adding or removing physical volumes, move extents to new disks, and resize logical volumes and file systems, including zfs and ext4, without downtime.

Extend the volume group by creating a new pv, then extend the volume group and the logical volume, and grow the mounted file system with zfs growfs, verifying files remain in /mnt/data.

Resize server1 lv1 in the server1-vg1 volume group to 768 mebibytes and keep it persistently mounted at /storage/data1. Create a new 128 mebibytes server1-lv2, format with zfs, and mount it persistently at /storage/data2, updating /etc/fstab and reloading systemd.

Explore Stratis storage management to create pools and dynamic file systems with thin provisioning, data and cache tiles, and snapshots, using commands like pool create and file system create.

Guide yourself through managing layered storage with Stratis, creating pools, volumes, and a thin provisioned file system. Verify dynamic growth and access data from snapshots.

Learn how the Red Hat virtual data optimizer, or video, uses zero block elimination, deduplication, and lz4 compression to reduce storage footprints on block devices and enable thin provisioning.

Create a thinly provisioned filesystem in the lab pool with straight storage management and a virtual data optimizer, enabling dynamic growth, a snapshot, and deduplication-aware compression for volumes.

Identify NFS shares, create a mount point, and mount or configure fstab; then use NFS conf to set the client to version 4 with TCP.

Master how to configure and test a network attached storage using NFS, persistently mount it via /etc/fstab, enable NFS v4 with the NFS conf tool, and verify with mount.

Explore the Linux boot process from firmware to systemd, learn to set default targets, isolate targets, and troubleshoot boot issues using grub2, initramfs, and kernel command line options.

Learn to manage boot targets with systemctl: set default to graphical or multi-user, switch targets without reboot, access rescue mode from the bootloader, and verify by reboot.

Reset the root password from boot by remounting the root filesystem as read-write and using passwd root, with initramfs options and rescue targets to recover access and inspect logs.

Reset the root password, recover from boot misconfigurations, and diagnose boot issues. Set the default target to graphical.target and practice emergency mode, bootloader edits, and SELinux relabeling.

Describe fundamental concepts of network addressing and routing for a Red Hat Enterprise Linux server, test configurations with command line utilities, and manage static hostname and name resolution using nmcli.

Master IPv4 addressing fundamentals, including binary, dotted decimal, and octets, and learn how subnet masks and CIDR define networks and hosts. Explore how default gateways and subnets organize networks.

Practice classful versus classless ipv4 addressing and design subnets for a four-building campus on 10.34.0.0/16. Identify network IDs, first usable, and broadcast addresses while reviewing private and public ip considerations.

Plan an IPv4 address scheme for Adatum's Houston, Mexico City, and Portland offices by sizing wired and wireless clients, selecting /24 subnets, and assigning appropriate subnets from the Toronto range.

Learn to generate a private RSA key and create a self-signed X509 certificate on Red Hat Linux using OpenSSL, including key sizing, passphrase protection, and setting a host-specific common name.

Explore creating a root certificate authority with openssl, generating a self-signed root CA and signing other certificates, with verification and long CA validity.

Create your first bash script, learn about the shebang, echo, and command substitution, make it executable, and run it to greet the user and display the date.

Make your first bash script executable with chmod +x, run it via ./my first script or bash my first script, and use a shebang such as #!/bin/bash or #!/usr/bin/env bash.

Explore bash syntax fundamentals, including variables, data types, command substitution, and special variables, with hands-on examples. Practice variable creation, local scope, and function usage in scripts.

Master bash basics: strings and variables, arithmetic with $(( )), arrays with zero-based indexing, and command substitution using backticks or $().

Master bash variables and special variables like $0, $1, $#, and $?, through hands-on scripting. Create and run a script that uses command substitution, processes arguments, and checks exit status.

Learn practical bash scripting to navigate and manipulate the Unix-like file system, mastering core commands like pwd, ls, cd, mkdir, cp, mv, touch, and managing file permissions.

Learn how to manage file permissions in Unix-like systems, view owner, group, and others with ls -l, and apply symbolic and numeric chmod to grant read, write, and execute rights.

Create a bash script that builds a project directory with src, docs, and tests, and files like main.py and readme.md, with 755 and 644 permissions. Note the SELinux dot.

Build an enhanced bash file operations script that uses special variables, command substitution, user input, timestamps, and permissions, and demonstrates editing configuration files for a flexible tool.

Master bash conditional statements by learning the basic if structure, with else and elif, and practice checking file existence and comparing numbers.

Explore bash condition testing with file, string, and numeric tests, using if, elif, and else, and combine conditions with and (&&) and or (||) for practical scripts.

Master bash loops to automate repetitive tasks using for, while, and until loops, learn loop structure, condition-based repetition, break and continue controls, and practical file processing examples.

Explore Bash loops, including until, while, and for loops, with break and continue, and nested loops. Use practical scripting to process txt files and automate tasks in Bash.

Create a bash script with a menu-driven interface for Linux system administration, using a while loop and case statements to support interactive tasks and debugging.

Refine an interactive menu script in Bash, adding a clear screen option and a guess-the-number game, using case statements, while loops, and error checking for user inputs.

Build a bash-driven Linux system administration menu that repeatedly prompts for tasks, and executes uptime, disk usage, CPU usage, memory checks, system logs, load averages, and large-file searches.

Build and troubleshoot a Linux system administration menu script in Bash using case statements and read prompts. Execute tasks like uptime, disk usage, and searching for large files.

Master bash functions by defining and calling them, passing parameters, returning values, and using local variables, with examples like greeting functions, calculations, and a number guessing game.

Explore how to use local variables in bash functions, prevent global side effects, and build reusable blocks with functions like check even odd and generate random number.

master bash error handling and debugging with practical examples, learning to check exit statuses, use traps and custom functions, enable verbose output, and build robust scripts that gracefully handle errors.

Explore bash error handling and debugging techniques, including short-circuiting on command failure with set -e, custom error functions, and traps for cleanup, with practical script examples.

Enable set -x for verbose output, add debug echo statements, and build an error handling function with a cleanup trap to debug and improve bash scripts.

Explore advanced bash scripting techniques through examples, including parameter expansion and indirect reference, associative arrays, and brace expansion. Learn to parse options, handle traps and subshells, and build complex scripts.

Master advanced bash scripting techniques, including indirect reference, associative arrays, and array operations, with practical examples of array slicing, process substitution, and brace expansion.

Master advanced bash scripting techniques including input/output redirection, here documents, subshells, command grouping, traps and signals, recursive functions, and parsing command line options with getopts.

Master advanced bash scripting techniques through a practical example that builds a script using declare arrays, a reverse function, directory traversal, trap cleanup, here documents, and counting file extensions.

Master bash script optimization and performance with practical techniques, from built-in commands and avoiding unnecessary processes to shell arithmetic, double brackets, and command grouping, including profiling for large data sets.

Improve bash script performance by using arrays instead of multiple variables, efficient parsing with read, and handling large data sets with awk, sort, grep -F, and parallel.

Profile and optimize bash scripts using the time command and set -x, then demonstrate practical optimization techniques with printf, shell arithmetic, awk, grep, and sort for faster script execution.

Improve bash script performance by debugging typos, validating file existence, and building practice scripts that generate data.csv, large_file.txt, and names.txt.

Optimize bash scripts through practical examples, generating data and names files, integrating smaller scripts into a main script, and measuring performance while prioritizing readability.