LPIC-1: System Administrator Exam 101 (v5 Objectives)
Senior Vice President of Content
NOTE: This course is for EXAM 101-500, which will replace the 400 series in early 2019!
This is our course introduction. Learn a little bit about what the exam is about, and who should take it. We also cover how it relates to the Linux+ exam.
About the Course Author
A little bit about myself.
Important Information about LPI Exam Discount Vouchers for 2019
Please view the following video for important information regarding LPI exam vouchers for 2019.
How to Use the Linux Academy Cloud Playground for this Course
This video provides an initial walkthrough on how to access and use Linux Academy's new Cloud Playground. The new service has replaced our now deprecated "Cloud Servers" platform. It is important to note that some videos in this course may use/refer to the old "Cloud Servers" platform, so here are a few important notes to remember and use: _ 1) If you see the instructor using (and/or telling you to use) login credentials such as "user" or "linuxacademy" AND the password "123456" - they will no longer work. Use the specific credentials provided to you (for the server you are using) in the new Cloud Playground user interface._ 2) You cannot log into the Cloud Playground servers as the root user. However, you can access the root shell by using the command `sudo -i`. _ **NOTE:** In this course, you may see the instructor running commands as the root user. In order to follow along with those commands, you must run the `sudo -i` command first. Otherwise, you will get a permissions error. _ 3) To access the servers GUI (if you provisioned a distribution that has one), you need to select "Actions" then "Graphical Shell" for your server in the Cloud Playground. _ **NOTE:** You cannot access the GUI via VNC Viewer as port 5901 is blocked. ____ Detailed documentation on the new Cloud Playground can be found here: https://support.linuxacademy.com/hc/en-us/articles/360019096651-Cloud-Playground-FAQ
101.1 Determine and Configure Hardware Settings
Pseudo File Systems
This lecture discusses the two pseudo file systems that are testable on the LPIC-1 exam: */proc* and */sys*. We will discuss the differences between these two, and illustrate some information that you can find within these two locations.
Working with Kernel Modules
This lesson focuses on the Linux kernel, and how to work with kernel modules. We will use various commands to find out what version of the kernel we are running, and how to unload, load, and find out information on kernel modules.
This lesson focuses on using some of the more common command line utilities to explore hardware on your Linux system. We also look into the */dev* directory, which is where these tools gather their information from. We will also explore udev and how it relates to the */dev* directory, and the role of D-Bus in all of this.*Note*: We describe the `lshw` command as interfacing with D-Bus, but it in fact queries the /proc file system directly. For viewing messages sent across D-Bus, take a look at the `dbus-monitor --system` command (not on the exam).
QUIZ: LPIC-1 101.1 Determine and Configure Hardware Settings
101.2 Boot the System
The Linux Boot Sequence
You must understand the basics of the Linux boot sequence for the LPIC-1 exam. Before we get into the deeper details, this lesson is an overview of what goes on right after you press the power button on your Linux computer. We will also take a look at the kernel ring buffer, which will show us important information from the boot sequence.
The LPIC-1 candidate must be aware of and understand the init sequence using sysvinit. We will explore the layout of init in some depth, and show you how older Linux systems boot up.
The LPIC-1 candidate must be aware of upstart, the init replacement created by Ubuntu. With this lesson, we show you what improvements upstart attempted with regards to how it helped to get a computer to boot faster, along with some resiliency methods that it attempted.
Systemd is now the predominant initialization service used on Linux computers. The LPIC-1 candidate must understand the basics of systemd, and how it is used in the computer's boot up sequence.
QUIZ: LPIC-1 101.2 Booting the System in Linux
101.3 Change Runlevels/Boot Targets and Shutdown or. Reboot the System
Change Your Working Environment: runlevels
Learn how to change the working environment of your system via System V Init runlevels. Even though this technology is not used as much anymore, the LPIC-1 candidate must know how to perform these tasks using commands such as runlevel, telinit, and init.
Change Your Working Environment: targets
The LPIC-1 candidate must know how to change a system's target for different operating environments. This lesson covers how this is done using systemd by using the systemctl command.
Reboot and Shutdown Your System
This lesson shows you the various commands that can be used to shut down and power off your Linux computer. An LPIC-1 candidate will need to know how to use the `poweroff`, `reboot`, `shutdown`, and `systemctl isolate` commands to restart or bring a computer down from the command line. We also briefly introduce ACPI, which the LPIC-1 candidate needs to be awareness of.
QUIZ: LPIC-1 101.3 Change Runlevels/Boot Targets and Shutdown or Reboot the System
102.1 Design Hard Disk Layout
Main File System Locations
This lecture discusses the main file system locations that the LPIC-1 candidate needs to understand: */*, */var*, */home*, and */opt*. We will demonstrate the `mount`, `fdisk`, `lsblk`, and `swapon` commands to view mounted locations, and we will begin our discussions on partitions.
Introduction to LVM
Here we will take a quick look at the basics of LVM. You will not need to know all of the ins and outs of LVM for the LPIC-1 exam, but you will need some basic familiarity with it. We will show you the structure of an LVM layout, along with some commands that will let you scan a system with LVM to see its structure.
102.2 Install a Boot Manager
In this lecture, we review legacy GRUB, the method with which older Linux systems would boot. We break down the various stages of the GRUB boot process, look at an example GRUB configuration file, and get our first look at the GRUB shell.
This lecture focuses on the next generation of GRUB, the GRUB2 boot loader. We will also look at how UEFI systems work, and why they offer more features over the old MBR systems. We see an example of modifying a GRUB2 file, and how to regenerate a new binary from it.
Interacting with the Boot Loader
In this lecture, we work with the GRUB boot menu in both legacy GRUB and GRUB2. We will practice booting the system using different kernel boot options, and learn how to reinstall GRUB to our disk. We even do a manual walkthrough of booting our computer using one GRUB command at a time.NOTE: You will not be able to follow along with this lecture using the cloud servers. You will need a locally installed virtual machine, as you will not have access to any boot menues from the cloud servers.
QUIZ: LPIC-1 102.1 and 102.2 Hard Disk Layout and Installing a Boot Manager
102.3 Manage Shared Libraries
Manage Shared Libraries
In this lesson, we discuss what library files are and the differences between shared and statically linked files. We show you some commands that will build a new library cache for you and why that is important. You will learn about the various configuration files that point to library directories, and how to use an environment variable to set up a temporary library location.
102.4 Use Debian Package Management
The Advanced Package Manager (apt)
In this lesson, we look at the `apt` command. A candidate for the LPIC-1 exam needs to know the most common commands to use with apt to install, remove, and upgrade packages. We explain how `apt` works behind the scenes, and update a cloud server. We will also use `apt` commands to get more information about packages.
Using Debian Package (dpkg)
This lesson focuses on using the Debian package tool, `dpkg`. We will practice the most commonly used commands and options for `dpkg`, and see how they compare to similar functionality in `apt`. We will explore the contents of a *.deb package file*, and learn how to reconfigure one that has already been installed.
102.5 Use RPM and YUM Package Management
The Yellowdog Updater, Modified (YUM)
This lesson will show you how to use the most common `yum` commands to install, remove, and update software on a Red Hat based system. We will also look at *zypper* and *dnf* package managers for other rpm based systems. We even use the *yumdownloader* utility to download an rpm package to use later.
The Red Hat Package Manager (rpm)
Learn how to use the `rpm` command to manage packages on Red Hat based systems. You will see how to query, install, remove and upgrade software with the venerable `rpm` command. Also, we show you how to use the `rpm2cpio` command to extract the contents of an rpm package
Installing and Managing Packages on Red Hat/CentOS Systems
QUIZ: LPIC-1 102.3, 102.4 and 102.5 Shared Libraries, and Debian and Red Hat Package Management
102.6 Linux as a Virtualization Guest
Virtualization and Containers
This lesson introduces the basic concepts of virtualization and containers. Learn about their similarities and differences, and what the two technologies can offer for resource management. We also introduce tools that are helpful when deploying virtual machines in a cloud environment.
103.1 Work on the Command Line
Your Bash Shell Environment
We dive into the Bash shell environment and learn how to create our own Bash variables and functions. Not only is this helpful for now, but it will come in handy when we start discussing shell scripts. We also take a look at a few new commands and find out how to modify our Bash configuration.
Bash History and the Manual Pages
In this lesson, we explore how Bash records command within their history in more depth. We will also learn about the *man pages*, and how you can navigate them to learn more about commands and configuration files on your system. This is crucial for any Linux System Administrator, including LPIC-1 candidates.
QUIZ: LPIC-1 103.1 Work on the Command Line
103.2 Process Text Streams using Filters
Basics of Viewing Text Files
This lesson revisits the `cat` and `less` commands, and we look at a few other new commands that can be used to view text files. We also learn how to view the contents of files that are compressed. All of these are testable commands on the LPIC-1 exam.
Text File Statistics
This lesson explores how we can glean some information from our files, such as how many lines they contain, the amount of words within a file, and byte counts. We will use the `nl`, `wc`, and `od` commands to dive deeper into the contents and structure of text files. We also learn how to use hash values to verify the integrity of files.
We continue our exploration of the command line by introducing some common text manipulation commands. Learn how to filter data in files based on characters and sort the output. We also learn how to print out unique values from a file. Find out how to extract data from a file based on position and to combine files together.Note: Download the *stats.txt* and the *list.csv* files from [https://github.com/linuxacademy/content-lpic-1](https://github.com/linuxacademy/content-lpic-1) if you wish to follow along with the examples.
More Text Manipulation
In this lesson, we learn some basic usage of the `sed` command. We also discuss the `split` command and how you can put files back together after you break them apart with `split`. Understanding these commands, as with all Bash commands that we discuss, are crucial for passing the LPIC-1 exam.
103.3 Perform Basic File Management
Working With Files
Learn the basic commands necessary for working with files: `ls`, `cp`, `rm`, `mv`, `touch`, and `file`. We will practice each of these commands and display their behavior. Understanding these commands and many of their switches are crucial to the LPIC-1 candidate.
Working With Directories
Learn how to navigate your Linux system with the `cd` command, and discover some of the Bash shortcuts that you can use to get around. We also look into creating and removing directories, and we discuss the importance of the PATH environment variable.
File and Folder Compression
This lesson focuses on archiving and compressing files. We will use the venerable `tar` command, and use various compression algorithms such as *gzip*, *bzip2*, and *xz*. We also work with the `dd` command and show you how to use it to back up your master boot record.
In this lesson, we will work with the powerful `find` command. We will locate files based on a variety of criteria, and have the `find` command automatically execute other commands based on its results. The `find` command is another crucial tool for any Linux system administrator's collection.
We have introduced file globbing with the star `*` character, now we will look at some other patterns that we can use to locate files. File globbing is very useful to the Linux system administrator as they traverse their file system looking for various files and folders.
QUIZ: LPIC-1 103.2 Process Text Streams using Filters
103.4 Use Streams, Pipes and Redirects
Understanding Standard Input, Output, and Error
In this lesson, we work with the fundamentals of standard input, standard output, and standard error. We have already been using some of the concepts in the course up to this point, but now we are going to take a step back and find out what is going on 'under the hood.' We work with redirecting these messages to other commands and files, and what their specific file handles are.
Redirecting Output to the Screen and a File
We complete our section on redirecting stdout and stdin by introducing two new commands: `tee` and `xargs`. Both of these commands are useful when working with long commands and multiple files. We also learn how to use the `xargs` command to help make our find commands more efficient.
QUIZ: LPIC-1 103.4 Use Streams, Pipes and Redirects
103.5 Create, Monitor, and Kill Processes
Reviewing the State of Your System
This lesson introduces you to how Linux processes work. We will utilize the `ps` and `top` commands to view running processes on a system and find out how we can filter the results from these commands. Every Linux system administrator needs to know what is going on with their systems in order to effectively manage them.
We continue our discussion about system processes by learning how to stop them using different signals. We take a look at the *signals man page* to learn where they are defined, and we use various commands to glean information from our existing processes. We also learn about the `uptime` and `free` commands to get more information about the state of our computers.
Keep a Process Running
This lesson focuses on how to keep processes running on a system, even if you are not actively on the computer. We learn about the *screen* and *tmux multiplexing* window managers, which allow you to keep remote sessions active on a system. We also look at running jobs in the background, and how to keep tabs on those processes and stop them when you need to.
103.6 Modify Process Execution Priorities
Understanding and Changing Process Priorities
This lesson will focus on process priorities. Learn about the default priority an application receives when it starts up, and how to change the priority for a process. We will accomplish this with the `nice` and `renice` commands, and see how we can do the same with `top`.
QUIZ: LPIC-1 103.5, 103.6 Managing Processes
103.7 Search Text Files using Regular Expressions
Introduction to Regular Expressions
This lesson introduces regular expressions. The use of regular expressions is a powerful means of locating text within files, in a variety of patterns. We cover the most commonly used expressions that you will need to know for the LPIC-1 exam.
Using Regular Expression Tools
Learn how to use some other tools from the command line to work with files using regular expressions. The LPIC-1 exam does not expect you to be a master of regular expressions, but it does expect that you know how to use them at a basic level with a variety of commands.
103.8 Perform Basic File Editing Operatins in vi
Using the Vi/Vim Text Editor
QUIZ: LPIC-1 103.7 and 103.8 Searching Text Files and Performing Basic File Edit Operations in Linux
104.1 Create Partitions and Filesystems
Legacy MBR Partitions
This lesson will show you how to use the `fdisk` and `parted` commands to create legacy MBR partition tables. Note that a local virtual machine was used for this so we would have extra disks to create partitions on. It is recommended that you set up your own local virtual machine to try these commands out on your own.
This lesson focuses on GPT partitions. We will use the `gdisk` command and the `parted` command to create new partitions using GPT. The LPIC-1 exam expects each candidate to understand the differences between MBR and GPT and how to create partitions in either format.
In this lesson, we create our own swap partition. We also get an introduction to the */etc/fstab* file, and briefly discuss its layout. All of these skills are important for the Linux System Administrator, as well as for those seeking to pass the LPIC-1 exam.
Creating Linux File Systems
In this lesson, we move onto creating regular file systems under Linux. We learn about some of the various file systems available to Linux, and what their uses are. This is the stepping stone to mounting file systems and partitions to directories.
104.2 Maintain the Integrity of Filesystems
Disk Space Usage
This lesson looks at how we can determine the amount of disk space that is in use and available on a Linux computer. We also discuss inodes, which can be a sneaky problem if you run out of them. We will look at the `du` and `df` commands, and how we can use them to track the status of our hard disks.
Maintaining a Filesystem
This lesson will show you the commands that you need to know in order to maintain your file systems. Linux file systems are very robust, but there may be times when you need to make adjustments to them, repair them, or just see how they are configured. We will discuss a variety of commands, such as: `fsck`, `e2fsck`, `tune2fs`, `xfs_repair`, `xfs_fsr`, and `xfs_db`.
104.3 Control Mounting and Unmounting of Filesystems
Understanding Mount Points
This is a quick lesson on how mounting works. We show you a short animation that describes the mounting process, and what happens when data gets saved to a directory.
Mount and Unmount Filesystems
Now that we have some basic knowledge pf mounting file systems, we will take a deeper look at how this works using various options. We also add a new mount point to our */etc/fstab* file to make it permanent and show an example of what happens when you save data to a file system that is not permanent.
QUIZ: LPIC-1 104.1 - 104.3 Creating and Maintaining File Systems
104.4 Manage File Permissions and Ownership
Basic File and Folder Permissions
This lesson breaks down the basics of file and folder permissions. Before we can learn how to modify permissions, we must first learn how to read them. We discuss both symbolic and octal permissions.
Modify Basic Access Modes
Now that we have an understanding of basic permissions, it is time to learn how to modify them. We will cover the `chown`, `chgrp`, and `chmod` commands to learn how to change permissions, also known as `access modes`.
Modifying Advanced Permissions
This lesson will focus on the more advanced topics of permissions. Here we will discuss the uses and importance of: the sticky bit, suid bit, and sgid bit. These permissions should not be overlooked so as to keep a Linux system safe and secure.
Default File and Folder Permissions
Find out where the default permissions of directories and files come from, and how you can change their values. We will also explore the differences between a regular user's file and folder permissions to that of the *root* account. These are important topics to consider when one is evaluating security within a Linux system.
Managing File Attributes and Permissions
104.5 Create and Change Hard and Soft Links
This lesson discusses links, which are essentially shortcuts to other files and folders. We demonstrate the creation of a symbolic link, and how it relates to the original file. Be sure to check out the lab for this section, as we dive deeper into the practical uses of both hard and soft links.
104.6 Find System Files and Place Files in the Correct Location
File System Hierarchy Standard
In this lesson, we discuss the file system hierarchy standard. This is the "standard" by which files and folders are laid out on a Linux file system. This is important information since, as a system administrator, you would need to know the typical locations for important configuration files and applications.
Finding Commands on a Linux System
Aside from the `find` command, there are a few other commands that we can use to locate files and folders on a Linux system. This lesson will introduce the `locate`, `updatedb` and `whereis` commands. We will also learn the differences between how these commands work as opposed to the `find` command.
Finding User Files and Reassigning Permissions in Linux
QUIZ: LPIC-1 104.4 - 104.6 Linux Permissions and the FHS
Linux+ and LPIC-1 Exam 1 Practice Exam
You have reached the end of the course! Here are some final tips and input on what you can look forward to doing next.
Take this course and learn a new skill today.
Transform your learning with our all access plan.Start 7-Day Free Trial