CompTIA Linux+ XK0-004 Certification Exam

Course

Intro Video

Photo of Michael McClaren

Michael McClaren

Linux Training Architect I in Content

Length

35:08:20

Difficulty

Intermediate

Course Details

CompTIA introduced their new Linux+ certification in April of 2019 and this Linux Academy course will help you prepare to succeed in taking it!

Intended for the IT Professional who uses Linux every day in their personal and professional lives. You only have to pass a single exam now, but keep in mind you will no longer get the LPI 2-for-1 certification as a result.

Designed to cover job-focused Linux foundational skills that are in demand, this certification preparation course will prepare you for the exam on this new certification. The exam covers tasks that are associated with all major distributions of Linux and helps set the foundation for later, more advanced vendor or distribution specific knowledge.

The original CompTIA Linux+ by LPI exam will be available concurrent with this new exam until October of 2019.

Syllabus

Course Introduction

About the Course

About This Course

00:03:50

Lesson Description:

We start this course off with a quick introduction to what you can expect from this class. We will describe the prerequisites for this course, its aim, and how to best prepare for the exam.

About the Certification Exam

00:05:07

Lesson Description:

Here is a breakdown of the Linux+ exam. This includes a listing of the various testing domains and their percentage weights, the cost information and how to register for the exam, along with the layout of the exam itself.

About the Author

00:00:49

Lesson Description:

This video is just a short introduction about myself.

Hardware and System Configuration

Linux Boot Process Concepts

The Linux Boot Process

00:03:56

Lesson Description:

We kick things off with a look at the Linux boot process. We will cover some terms that you may not know yet, however as we progress through the course it will all click together. Before we can get into areas such as setting up hard drives, boot loaders, initialization systems, and other topics we should first see what goes on 'under the hood' when we boot up a Linux computer.

Legacy GRUB

00:07:10

Lesson Description:

Now that we have a basic handle on the boot process, we are going to look deeper into the boot loaders, which are the software systems that hand the system over to the Linux kernel. We will first look at legacy GRUB, which is still installed on older Linux systems. This is important not only for the exam, but also so that an administrator understands how these older Linux systems are booted up.

GRUB2

00:07:39

Lesson Description:

Now that we have an understanding of the legacy GRUB system, let's take a look at how modern Linux distributions implement the newer version, GRUB2. GRUB2 uses a slightly different format for its configuration files, but we will see how to work with those in this lesson.

Interacting with the Boot Loader

00:10:39

Lesson Description:

In this lesson, we will walk through how to interact with both the legacy and modern GRUB boot loader. You will want to know how to do this should you need to boot into an emergency mode on your Linux system, or manually boot into a different operating system. NOTE: You will need to practice this on your own virtual machine, as performing these tasks will not be possible in a cloud-based server (as you will not have access to the GRUB menu on such systems).

initramfs

00:10:38

Lesson Description:

This lesson will explore the initramfs file in a little more detail with the help of the lsinitrd command. We will also look at rebuilding our own initramfs file with the dracut command. This is a useful utility that can be used to strip out (or add) modules that the kernel can use when booting of a Linux installation in various types of system deployments.

Other Boot Options

00:03:45

Lesson Description:

Along with booting Linux from a USB or CD/DVD disc, we can use the network cards on our computers to boot Linux from files on a network. This video will discuss the PXE boot system, and demonstrate a PXE boot scenario where we would install a Fedora system. Note that for the exam, you just need to be familiar with PXE booting a system over a network, you do not need to demonstrate the configuration of PXE or TFTP.

Install, Configure, and Monitor Kernel Modules

Working with Kernel Modules

00:06:19

Lesson Description:

Kernel modules provide the helper functions that allow the kernel to work with various types of hardware and software components. In this lesson, we take a look at how to view what kernel modules we have loaded, and how to add and remove them while our system is up and running.

More Kernel Module Commands

00:08:23

Lesson Description:

This lesson is a follow up to the previous lesson on working with Linux kernel modules. We will look at some legacy kernel module commands, such as insmod and rmmod as well as how dependencies are handled via the depmod command. We will also learn about the locations of various Linux driver files.

Dealing with a Kernel Panic

00:07:45

Lesson Description:

NOTE: This lesson was done on a local virtual machine. Do not attempt this in a cloud server. This lesson will show you how to handle a basic kernel panic. We will look at what a kernel panic looks like, and some methods and tools that we can employ to get our systems back up and running after a kernel panic happens.

Configure and Verify Network Connection Parameters

Networking Fundamentals

00:09:44

Lesson Description:

Linux is classified as a Network Operating System (NOS). So in order for us to understand what we can do with Linux in this capacity, we must first get a grasp on networking fundamentals. This lesson will break down the basics of network terminology and protocols before we get into configuring networking services on our Linux systems.

NetworkManager

00:17:29

Lesson Description:

This lesson dives into the usage of NetworkManager's command-line tool: nmcli. This application is used on most modern Linux distributions, and is quite useful in setting up a variety of network connection types. We will start off with the basics in this lecture. Note that you will want to practice these commands on a local virtual machine, so as to not disconnect yourself from a remote system.

Legacy Networking Tools

00:04:38

Lesson Description:

Along with the use of NetworkManager tools, a Linux system administrator needs to know how to use the legacy networking tools. With this lesson, we will take a look at the older interface commands, and the original route command.

Testing Connectivity

00:10:00

Lesson Description:

This lesson is a predecessor to our later troubleshooting lessons, but it fits in nicely right here. After you get your system connected to a network, it is not a bad idea to test its connectivity to your local network, and even the internet. We will look at some common tools that can be used for such a purpose.

The Basics of DNS Resolution from Linux

00:12:02

Lesson Description:

Up to this point we have talked about IP addresses. How does our browser know how to get to a page when we type in a site's name? This lesson focuses on DNS resolution, which turns those website names into IP addresses so that our computers know where to go. We will also look at some tools and configuration files in Linux that assist with our system's DNS settings.

Bonding and Link Aggregation

00:05:32

Lesson Description:

In this lecture, we are going to take a high level overview of what bonding and link aggregation are and how they are used within Linux. You will often hear the term 'bonding' getting interchanged with 'teaming' as that is essentially what you are doing, you are grouping multiple network interfaces into a single interface that will perform based on a mode that is assigned to it. We will also look at link aggregation, where we can combine multiple network interfaces into a single logical interface, called a 'bridge', which will allow multiple systems to communicate as if they ware on the same network.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Manage Storage in a Linux Environment

Pseudo (Virtual) Filesystems

00:08:08

Lesson Description:

Our first lesson into the world of Linux storage involves the pseudo file system locations. We will introduce the concepts of a file system, and how data is organized on a hard disk within Linux. We will also look at a couple of commands that will help us navigate the contents of a file system.

Main Filesystem Locations

00:10:43

Lesson Description:

This lecture looks at the main file system locations that every Linux system administrator needs to know, along with a look at the concepts of Linux disk naming and partitioning. We will look at a live system so that we can apply these concepts.

Filesystem Hierarchy Standard

00:06:06

Lesson Description:

We continue our exploration of the Linux filesystem as we look at the purpose of each directory in turn. We also discuss the FHS (or Filesystem Hierarchy Standard) as it applies to modern Linux distrubitions. This is the groundwork for future lessons on creating filesystems and determining where they should be mounted to.

Legacy MBR Partitions

00:08:08

Lesson Description:

In this lesson, we will take a look at legacy MBR partitions, which is the older style of partitioning schemes from the MS-DOS days of computing. We will discuss the method used to create an older style of partition setup, using both the fdisk and parted commands.

GPT Partitions

00:06:13

Lesson Description:

This lesson expands our Linux storage knowledge with the creation of GPT partitions. We had discussed in a previous lesson the benefits to this newer storage scheme, so now we will learn about the tools that we can use to create partitions of this type: gdisk and parted.

Swap Partitions

00:16:05

Lesson Description:

Along with regular paritions, the swap parition is equally important on Linux systems. The Linux kernel uses this partition to 'swap out' areas of memory from RAM that are not used frequently, so that quicker access to RAM can be granted to other applications. This lesson delves into the creation of a swap partition, and how to make it a permanent resident on the Linux host. We will look at gdisk once again, and introduce the swapon, swapoff, and mkswap commands.

Creating Linux Filesystems

00:09:50

Lesson Description:

With our newfound knowdedge on creating partitions, we now look at how to create a file system on them. This is important, as we need a partition to contain a filesystem in order to actually store data on a disk. We will look at the mkfs command along with an overview of the more popular file system types used within Linux.

Understanding Mount Points

00:01:38

Lesson Description:

This is a short introduction to how mount points work in Linux. Understanding the concepts behind mount points is crucial to working with storage in Linux.

Mounting and Unmounting Filesystems

00:13:06

Lesson Description:

Now we have made it to where we can permanently set up our new file systems. This lesson will show you how to work with various mount options, as well as making modifications to the /etc/fstab file for permanently attaching your new storage to your Linux system.

Multipath Storage

00:02:22

Lesson Description:

In this lesson we will be taking a look at multipath storage and how it can provide high avilability and failover in storage devices. This is most often seen on Storage Area Network (SAN) implementations when a network share that is mounted locally needs to be highly available. As this is something that required additional harware to implement we will be covering the concept here and touch on the points that are needed for the exam.

Maintaining a Filesystem

00:15:00

Lesson Description:

It is important that we understand how to maintain our filesystems on any computer, regardless of the operating system. This lesson looks at how these tasks are performed on the main Linux filesystems, so that we can be sure that our data will be available when we need to access it from our disks.

Disk Space Usage

00:10:20

Lesson Description:

Along with the maintenance of our file systems, we need to be aware of how much storage space we have in use. Not only must we be cognizant of the size of the files, but also how many inodes are in use on our computers. This lesson will show you how to keep track of your disk space usage using a variety of tools.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Localization

Working with the System's Locale

00:09:20

Lesson Description:

If you work within an organization that has a global presence, you might be responsible for making sure your systems comply with a regional locale setting. This lesson will dive into how to determine a system's locale settings and make adjustments to it. We will also look at how to convert files from one locale's encoding to another.

Time and Date on a Linux System

00:08:32

Lesson Description:

Along with a system's locale settings, the computer's time and date need to be properly set. Correct time on a system is essential for system logging, authentication from remote systems (such as Kerberos), and scheduled jobs. We will look at how to determine the system's configured time settings, as well as the tools used to modify these settings.

System Operations and Maintenance

Conduct Software Installations, Configurations, Updates, and Removals

The Advanced Package Manager (apt)

00:10:24

Lesson Description:

We now get to enter the realm of software management within Linux. We start things off with the apt command line tool for handling software on Debian-based Linux distributions. We will install, remove, and clean up our software cache with this utility, and show you how to keep your Debian-based Linux install up to date.

Using Debian Package (dpkg)

00:06:45

Lesson Description:

Continuing on with our Debian package management, we now turn our attention to the dpkg package tool. This utility is used to install, remove, update, and manage individual Debian packages, as well as gather various bits of information on the software that they contain.

The Yellowdog Updater, Modified (yum)

00:10:10

Lesson Description:

We now switch gears from software management on Debian-based systems to managing packages on Red Hat-based Linux distributions. This lesson looks at the yum command, which much like the apt command will handle packages and their dependencies to make software management a lot easier for us.

The Red Hat Package Manager (rpm)

00:09:20

Lesson Description:

Next up in our discussions on Linux package management, we take a deeper look at the rpm command and its associated package types. You will learn about the command itself and how it can be used to manage software on your Linux system, as well as how to extract data from an rpm file.

DNF and Zypper

00:03:33

Lesson Description:

Now that we have looked at yum, we will take a look at the more modern package manager dnf for Fedora and the newer versions of Red Hat Enterprise Linux. Also, we shall give zypper a spin, which is the rpm package manager for the openSUSE and SLES Linux distributions.

Compiling Applications

00:06:47

Lesson Description:

In this lesson we will walk through the process of compiling an application. Here we will be compiling the nginx web server from source. We have to configure the makefile using the supplied configure script, and then look at the resulting makefile. We'll use that for running the make utility to complile. Once all of that is completed, we will look at the additional steps neccessary for getting the application up and running.

Managing Shared Libraries

00:07:00

Lesson Description:

Linux system administrators need to not only understand how to manage software installations, but also how they use library files for extra functionality. This lesson takes a quick look at what library files are, the different types (such as dynamic and static), and how to configure your system to use library files that your software requires.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

01:00:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Linux Graphical User Interfaces

The Primary Linux Desktops

00:06:21

Lesson Description:

This lesson will introduce you to some of the more popular Linux desktop environments: GNOME, XFCE, and KDE. We will discuss the similarities and differences between each one, as well as some of the technologies that go into a Linux desktop.

Assistive Technologies on the Linux Desktop

00:08:37

Lesson Description:

In this lesson, we will look at some of the assistive technologies available on a Linux desktop. These technologies are software packages that can aid computer users that are hearing and/or visually impaired. There are also utilities that can assist older computers users that may have trouble utilizing a mouse or keyboard. We will walk through the applications available within a default GNOME desktop installation, and see what each of them modify to help computer users with specific needs.

The Basics of X11

00:04:39

Lesson Description:

This lesson will introduce you to the basic architecture of how the X11 protocol is used to show items on a desktop. We will also introduce the Wayland protocol, which is steadily becoming a fully capable replacement for the Xorg software stack. We also have provided a download link where you can get a pre-built CentOS 5 virtual machine image that is ready for you to practice with an older Xorg configuration, since most modern Linux distributions utilize both Wayland and the newer versions of the X11 protocol.

Remote Graphical Connections

00:14:54

Lesson Description:

This lesson will show you some of the various tools availabe for Linux that can be used to connect to a remote desktop. We will demonstrate the configuration and usage of VNC, and introduce you to the SPICE protocol.

Understanding Devices in Linux

Investigating Hardware

00:09:08

Lesson Description:

In this lesson, we will learn about some of the subsystems that Linux uses when communicating with hardware. We will discuss udev's roll in handling hardware devices, and how we can use the /dev pseudo-file system to view our components. We will also look at some command-line tools that are commonly used to gather information about our hardware, such as lspci, lsusb, lscpu, and we revisit lsblk with further details.

The Common Unix Printing System (CUPS)

00:13:21

Lesson Description:

In this lesson, we will take a detour into the world of printing from Linux. We will introduce the CUPS service, which was created by Apple and used on practically every Unix-like operating system. We will demonstrate how to configure this service through its web interface, and how to perform some basic troubleshooting of print jobs. We will also introduce the main configuration files that a Linux system administrator needs to be aware of for CUPS.

The Line Printer Daemon

00:09:42

Lesson Description:

We wrap up the discussions about printing in Linux with a walkthrough of working with printers from the command line. Everything that can be done from the CUPS web interface can also be done from the command line, and this lesson will show you how. We will use the lpd toolset to add and remove printers, enable and disable them, and manage print jobs. Everything that can be done from the CUPS web interface can also be done from the command line, and this lesson will show you how.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

01:30:00

Manage Users and Groups

Adding and Removing Users

00:07:00

Lesson Description:

Now we get to find out what it takes to get new users added to the system. We will discuss local account creation within Linux, and also how to remove local accounts. We will introduce the useradd and the userdel commands with some of their most common options.

Adding and Removing Groups

00:04:20

Lesson Description:

Now that we know how to add and remove users on a Linux system, we will look at creating group accounts. Groups are just a collection of users that have permissions assigned to allow or deny access to various resources on a Linux system. We will look at a user's group membership, how to add a new user to a group, create a group, and delete a group. We will expand on group accounts in further lessons.

User and Group Configuration Files

00:11:58

Lesson Description:

This lesson takes a deeper look at the configuration files involved with local user account creation and management. We will look at the files where the user and group acount information is stored (/etc/shadow, /etc/passwd, /etc/group) and the various files that are used during account creation.

User and Group Modifications

00:11:13

Lesson Description:

Modifying user accounts is just as important as creating them. There may be times when you need to lock a user's account, or set password ages, or change other aspects of a user's local account. We will explore some methods that utilize the usermod and groupmod commands to handle modifications for our local Linux accounts.

Securing Local Logins

00:05:23

Lesson Description:

This lesson is a continuation of our lesson on modifying local users, where we look at locking down (and unlocking) local login accounts. We will also explain the mechanism behind how the Linux kernel allows a user to change their own password.

Your Bash Shell Environment

00:15:04

Lesson Description:

In this lesson, we are going to take a deeper look at the Bash shell environment, the default shell used on most Linux distributions. We will look at how environment variables are constructed and used, how to create your own shell function, and how to use the type command to find out what is a built-in function to Bash or an actual program. We will look into using the set, unset, and shopt commands to modify the behavior of the shell as well.

Setting Up the Shell Environment

00:10:41

Lesson Description:

Now we take a look behind the scense of what happens when you log into a Linux terminal. We will explore the various files that are used to set up the shell environment, and we will also look at the differences in setting up a login versus a non-login shell. You will learn about which file to use to permanently store your own Bash environment modifications for aliases or your own Bash functions.

Customizing the Shell Environment

00:15:41

Lesson Description:

We take one more look at customizing our Bash shell environments, along with a walkthrough on how we can make our changes permanent. We review the Bash environment before we create our own functions and aliases for Bash, then we add them to our Bash configuration files so that they will be available on future logins.

Bash History and the Man Pages

00:11:17

Lesson Description:

This lesson provides a more focused look at the Bash history command and its configuration. We will also look at the all-important man command, which we use within Linux (and other UNIX-like operating systems) to view manual pages on the commands that we use and the configuration file information necessary to keep our systems up and running.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

01:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

01:00:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Automate and Schedule Jobs

Cron

00:10:09

Lesson Description:

We begin our section on scheduling jobs within Linux by looking at one of the oldest methods used to set up tasks for execution: cron. We will describe the crontab command and files that are used to schedule jobs, and their formats. We will also set up a test job, and learn how to prevent users from configuring a crontab on their own.

At

00:05:50

Lesson Description:

Along with cron we can use the at daemon to schedule tasks as well. The difference between the two is that cron is for recurring jobs, whereas at is used for one-off jobs to be run. We will look at setting up example jobs using at, and how to view them in a queue. We will also look at setting up security for at by denying or allowing users access to the service.

Systemd Timer Unit Files

00:09:03

Lesson Description:

We are going to jump ahead a little bit in this lesson and introduce the timer systemd unit file. We will go over systemd unit files in greater depth later, but timer unit files are used to schedule jobs and tasks, so it is first discussed here. We will look at the syntax required to set up a systemd timer unit, and the different types of timer units that we can utilize.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

01:00:00

Create, Modify, and Redirect Files

Working with Directories

00:10:58

Lesson Description:

We reveiw the basics of file system navigation with the cd command, and also creating our own directories with the mkdir command. Once more, we review the importance of the PATH environment variable and the role it plays in how we run our applications.

Working with Files

00:12:20

Lesson Description:

This next lesson should be a review for anyone taking this course. We are going to revisit the more commonly used file commands within Linux: rm, mv, cp, file, touch, and ls. These are some of the most basic commands that every Linux administrator must know, and we will show some uses of these commands here.

File Globbing

00:06:44

Lesson Description:

File globbing is one of the most commonly used techniques when locating files or directories by name, when you are not sure of the full name to use. We can use special characters within our Bash shell, that Bash will know to interpret as other characters when looking for files or folders. We will look at some very common uses of file globbing n this lesson.

Introduction to Regular Expressions

00:05:56

Lesson Description:

We are going to look at regular expressions, which are characters used in a way that allows us to help find patterns within a file. Regular expressions are used in script files and commands in a variety of ways, from very simple to extremely complex. We will look at some basic usage of regular expressions to get you started, and it is highly encouraged that you practice regular expressions on your own so that you can become familiar with reading a script that utilizes them and understanding what it does.

Using Regular Expression Tools

00:05:25

Lesson Description:

We continue the discussion of regular expressions by showing some demos using some tools that are commonly used in conjuction with regular expressions. We will look at sed, egrep, and fgrep and the differences between these utilities.

Understanding Links

00:05:23

Lesson Description:

We take our first look at links within Linux with a discussion of symoblic links. These act like shortcuts to files or folders on other operating systems. We will show you how to create a symoblic link and what happens when you modify the original file that the link points to.

Finding Files

00:09:10

Lesson Description:

In this lesson we will focus on the find command, which is used to, well, find files and folders on a Linux computer. The find comamnd is very versatile and powerful, and we will show you some ways that you can use it to look for files based on specific criteria, and how to perform actions on the find command's results.

Understanding Standard Input, Output, and Error

00:05:53

Lesson Description:

All of this stuff that gets printed to our consoles when we use commands actually has some extra stuff going on behind the scenes. We will discuss standard input (stdin), standard output (stdout), and standard error (stderr). All of these concepts play important roles in how we handle cammand inputs, outputs, and what we do with error messages. These topics are important when it comes to shell scripting and logging messages.

Finding Commands on a Linux System

00:03:32

Lesson Description:

Along with the find command for locating files and directories, we have a few other commands that we can use to locate items on our file system. These are the locate and whereis commands. We will discuss the difference between the find command and the locate command, along with its companion command updatedb. These are essential tools for a Linux system administrator as alternatives to the find command.

Redirecting Output to the Screen and a File

00:12:23

Lesson Description:

As a follow-up to our lesson redirecting stdout and stderr we will look at some commands that we can use to help extend what we can do with this data. We will explore the tee and xargs commands which can be helpful with stringing commands together, each command using a previous command's output as its input.

File and Folder Compression

00:12:36

Lesson Description:

Unfortunatley, we usually only have a finite amount of hard disk space on a computer. Luckily, we can compress files and folders to save space. This lesson will show you how to use a couple of basic backup commands, such as dd and tar, and how to compress files (and decompress them) using various compression techniques.

Using the Nano Text Editor

00:04:30

Lesson Description:

This lesson will start us off on a short section of using command line/TUI text editors. The first one we will look at is nano, the easiest one for new Linux users to work with. It is quite similar to the old EDIT command from DOS and early Windows.

Using the Vi/Vim Text Editor

00:06:18

Lesson Description:

This lesson is a short introduction to the Vi and Vim text editors. It is highly recommended that the exam candidate practice Vim using the vimtutor command, which is a wonderful built-in tutorial on how to use this versatile editor. We also have a Vim cheat sheet that you can download and use for this course.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

01:00:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Manage Services

init

00:09:20

Lesson Description:

In this lesson, we are going to look at the classic init startup daemon that was on most Linux distributions. It is still in use on some distributions to this day, but has mostly been supplanted by the modern systemd. However, there are still legacy systems that run init and it is important to know how it works "under the hood".

Red Hat Service Tools

00:05:43

Lesson Description:

This lesson looks at how classic init daemons were managed on Red Hat based distributions using the tools service, chkconfig, and ntsysv. These tools are legacy utilities, but you may still encounter them when administering older systems. Also, the service command currently can be mapped to equivalent systemd commands for managing daemons at runtime.

Upstart

00:06:07

Lesson Description:

This lesson is essentially historical information on Upstart, and how it helped to bridge the gap between the classic init system and the modern sytemd initialization system. Ubuntu was the first distribution to fully tackle parallel daemon initializations, and was used for a time on other Linux distributions as well. We will discuss the architecture of Upstart, and how it differed from the classic init daemon.

Systemd

00:05:44

Lesson Description:

This lesson will formally introduce you to systemd, the modern init replacement on most Linux distributions. The systemd daemon provides a lot of features over teh classic init and how services are started and handled. This will be an overview of what systemd does differently before we dive into specific components of the sytemd software stack.

systemctl

00:10:03

Lesson Description:

We will now look at the systemctl command, which is used to control services and daemons on a Linux system that runs systemd. This is a very versatile command, and we only scratch the surface of it in this lesson, but we will explore it more in future lessons. We will introduce the basics of starting and stopping services, as well as enabling or disabling them from starting up when the computer boots. We will also look at how to glean system information from the command.

Basics of a Unit File

00:09:41

Lesson Description:

In this lesson we will review the components of a unit file and its structure, along with their default locations (you can skip ahead to 5:17 for the unit file modification portion if you do not want the review). Then we will look at the commands that we can use to modify, or create 'drop-in' unit files to override settings from default unit files. We will then look at what is needed for our systems to use the new unit files without having to reboot the computer.

Target Unit Files

00:05:55

Lesson Description:

We will now look at our first unit file for systemd, and that is the target unit file. This type of unit describes how our computer's operating environment will be set up. We can quickly and easily change between different types of targets with the systemctl isolate command, as we will demonstrate here. We will also look at the construction of the target unit file, and find out which ones we have available on a given system.

Service Unit Files

00:08:41

Lesson Description:

We continue our discussion of systemd unit files by now looking at the most commonly used unit file for system administrators. The service unit file controls daemons and other programs that we need to have running on our systems when the computer boots, or when we need something to run in the background on demand. We will break down the service unit file, and look at some example administrative tasks that we can perform on a service unit.

Timer Unit Files

00:09:03

Lesson Description:

We are going to look at another systemd unit file, the timer unit. This unit type is meant as a replacement for the atd and cron systems for scheduling jobs or system events to take place at specific times. We will discuss the construction of the timer unit file, how to set the various types of timers up, and how to configure their start times.

Reviewing the State of Your System

00:06:24

Lesson Description:

This lesson reviews the basics of the ps command and how we can use it to review the running process on our system. We will also briefly discuss the top command to show how we can view running processes on a Linux computer in near real-time. It is important to be aware of what is running on our computers so as to understand what we can expect for a baseline on them.

Monitoring Processes

00:11:35

Lesson Description:

In this lesson, we are going to look at a few more commands to add to your System Administrator toolbelt that you need to know to help keep track of your system's resources and running processes. We will cover the uptime, free, pgrep, pkill, kill and signals that you can send to a process. These are some of the more important basic commands that you will need to know in order to help track a baseline state of your system.

Keeping a Process Running

00:11:43

Lesson Description:

Part of what a Linux System Administrator's list of tasks can often include ensuring that long processes will remain running. Sometimes installers from third-party sources can take a long time, or even software compilation jobs will require a good deal of time as well. We will look at some various methods that we can employ to keep a process running on either local or remote systems while we can continue to use these same systems for other tasks.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Summarize and Explain Server Roles

Core Network Servers

00:05:02

Lesson Description:

This lesson will breifly outline some of the core network server services that Linux can provide. We will look at DNS, NTP, and DHCP. We do not need to cover installation and management of these service, however the exam candidate needs to know what they are conceptually, and what network ports and protocls they use along with what software packages can provide these services.

Infrastructure Servers

00:05:24

Lesson Description:

We continue our discussion of network servers by focusing on network infrastructure services. We will discuss the concepts of an authentication server, load balancer, PKI server, and a server cluster.

Monitoring and Security Servers

00:04:38

Lesson Description:

This lesson briefly outlines monitoring, logging, and proxy servers. We will look at what these services do, their network ports, and some applications that provide the functionality described.

Common Server Systems for Client Use

00:05:15

Lesson Description:

This lesson will cover many of the different types of server platforms that you would find on a corporate network such as a print server, file server, and database server. We will also look at the server systems that you would access from home as well as from work such as mail and web servers. Once more, we provide listings of the most commonly used software packages that provide these services as well as their respective network ports.

Container Basics

00:02:53

Lesson Description:

In this lesson we will compare containers to traditional virtual machines. We will see how container runtimes such as Docker fit into the virtaulization stack, and discuss how containers are more efficient in some cases than traditional virtual machines.

Security

File and Directory Permissions

Basic File and Folder Permissions

00:05:09

Lesson Description:

This lesson reviews the basics of file and folder permissions on a Linux system. This is essentially the same material included with the LPI Linux Essentials course, but included here as a review. Understanding how permissions work, and the two methods for representing permissions in Linux, is a crucial skill that a Linux system administrator needs to understand in order to help secure their systems.

Modifying Basic Permissions

00:08:08

Lesson Description:

Continuing on from our previous discussion about reading basic file and folder permissions, we now explore some of the tools that we can use to modify those permissions. We will work with the chmod, chown, and the chgrp commands to make some basic adjustments to files and folders.

Modifying Advanced Permissions

00:18:45

Lesson Description:

Continuing on with our discussion of Linux permissions, we now look at some more advanced permission types that we can apply to files and directories on our systems. We will look at the sticky bit, the set group ID bit which is commonly used for collaborative group directories, and the set UID bit and why you may not find it used so much anymore.

Default Permissions

00:06:52

Lesson Description:

In this lesson, we discover where a system's default permissions for both files and folders originate from. While we are at it, we will also explore how to change those default permissions for an individual user. This is a useful skill to understand, so that you have the ability to make your system more (or less) restrictive on default permissions depending on your server environment.

File Access Control Lists

00:03:59

Lesson Description:

In this lesson we will see how file access control lists can help us make more granular settings in our file permissions. We will create some files, then make sure a user can view them by adding that user to the access control lists belonging to thos files.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Context-Based Permissions

Overview of SELinux

00:04:03

Lesson Description:

In this lesson we will lay the foundation for knowing SELinux. I will show you a quick diagram of how SELinux flows. Then we will look at discretionary access control vs. mandatory access control, as well as the mapping between SELinux users and Linux logins. Commands used in this lesson: Display the SELinux context: ls -Z View the mapping from SELinux users to Linux logins (requires elevated privileges): semanage login -l View the SELinux users details (requires elevated privileges): semanage user -l

SELinux Configurations

00:05:48

Lesson Description:

In this lesson we will take a look at the configuration of SELinux and discuss what enforcing, permissive, and disabled all mean. We will also take a peek at booleans and how they can be leveraged to modify the behaviour of the SELinux configuration to customize its enforcement. Commands used in this lesson: Get the current configuration (mode) of SELinux: getenforce Change the current configuration (mode) of SELinux: sudo setenforce Get the details of the current configuration: sestatus Get a list of SELinux booleans without descriptions: getsebool -a Get a long list of SELinux booleans: semanage boolean -l Change an SELinux boolean: set sebool

SELinux Policy

00:02:44

Lesson Description:

In this lesson we will explore the directory that contains the SELinux policy. We'll also take a look at the contents of some of the policy files, and discuss the difference between targeted and strict policies.

SELinux Tools

00:09:46

Lesson Description:

In this lesson we will take a look at the tools that can be used to troubleshoot and correct issues with SELinux contexts and settings.

AppArmor

00:06:07

Lesson Description:

In this lesson we will look at AppArmor, which is used primarily on Debian and SUSE distributiuons. We will contrast how permissions are applied using path-based permissions for the MAC process, and we will take a quick look at how to configure AppArmor paths and Tuneables.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Privilege Escalation

Elevating Privileges

00:07:31

Lesson Description:

In this lesson we will explore the process of elevating privileges in the Linux environment. There are a few ways to accomplish this, and we will take a look at the most common. This process is important, since we never want to login as the root user. If we need to run commnands that are not in our security scope, we should instead elevate to accomplish these tasks.

Sudo Configuration

00:08:50

Lesson Description:

In order to allow the privilege elevation, we will need to configure sudo. In this lesson we explore the configuration of sudo and I'll introduce an error, then demonstrate the fix. Bonus points if you can spot it before I correct the issue! Remember always use visudo to edit the sudoers configuration, and never edit the file in a standard editor.

User Account Types

00:04:59

Lesson Description:

In this lesson we will take a quick look at user account types. We will examine the root account, standard users, and service accounts. This will show what makes them different, as it applies to the Linux Plus exam.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Access and Authentication Configuration

PAM Basics

00:03:03

Lesson Description:

In this lesson we will take a look at the Pluggable Authenticaiton Modules (PAM) in Linux. This system is designed to provide a single interface for processes and services to leverage built-in authentication and authorization methods within a Linux system.

PAM Configuration

00:09:12

Lesson Description:

In this lesson we will continue working with Pluggable Authenticaiton Modules (PAM). We will see how modules are applied, and discuss some of the key terms that are used inside of the PAM configuration files. We will also see how to configure password rules and user lockouts.

PAM and LDAP

00:03:27

Lesson Description:

In this short lesson we will look at how to enable the pam_ldap module to allow authentication against the Lightweight Directory Access Protocol (LDAP). This is a centralized credential store that can be used for single sign on. We will not be covering the configuration of the actual LDAP service, but we will discuss how to enable it in PAM and how to stack the PAM modules so that LDAP integration works correctly.

Secure Shell (SSH)

SSH Basics

00:03:49

Lesson Description:

In this lesson we will be looking at the most absolutely basic way to complete an SSH connection. We will examine the SSH command and the known_hosts file.

SSH Configuration

00:08:31

Lesson Description:

In this lesson we will be looking at creating SSH keys and getting them copied over to a server. We will then take a quick peek at the location of the server configuration files for SSH, and cover some settings for the SSH daemon on that server.

SSH and TCPWrappers

00:04:09

Lesson Description:

In this lesson we will be looking at using TCP wrappers to secure SSH access to our server. This secures incoming connections by using the hosts.allow and hosts.deny files located in the /etc directory.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Terminal Types

TTYs and PTYs

00:05:14

Lesson Description:

In this lesson we will take a look at Terminals in Linux, and the difference between pseudo terminals and normal terminals. We will also take a look at the /etc/securetty file and how it can be used to determine which terminals the root user can log into.

Public Key Infrastructure (PKI)

PKI Keys and Certificates

00:06:39

Lesson Description:

In this lesson we will be looking at Public Key Infrastructure and how this can be leveraged to both verify identity and encrypt traffic. We will also take a quick look at OpenSSL and how it can be used to verify digital signatures.

Virtual Private Networking (VPN)

IPSec

00:01:52

Lesson Description:

In this short lesson we will talk about the Internet Protocol Security (IPSec) implentation of Virtual Private Netowrks (VPNs). We will quickly talk about tunnel vs. transport mode, and the OSI layer that IPSec is implemented (Layer 3, the network layer). Since IPSec VPN is implemented at OSI Layer 3, it is application independant.

SSL / TLS

00:02:43

Lesson Description:

In this lesson we will take a look at the application layer implementation of Virtual Private Networks (VPNs). This implementation uses SSL/TLS to secure data in transit. The most popular software for this purpose is OpenVPN, and we will take a quick look at where the SSL is applied in the server configuration for the OpenVPN software.

Security Best Practices and System Hardening

Protecting The Boot Sequence

00:02:17

Lesson Description:

In this very short conceptual lesson, we will see the reasons why you would want to implement both BIOS/UEFI passwords as well as a boot loader password on all of your systems. This is the first step in securing the system and is one of the commonly overlooked steps in system security.

Additional Authentication Methods

00:06:11

Lesson Description:

In this lesson we will be looking at authentication methods in Linux. we will be talking about Multi-Factor Authentication (MFA), as well as the factors that can be used. Then we will wrap it up by looking at the backend technologies that can be used, such as KERBEROS and LDAP. These topics are on the exam, but implementation is not required. It is enough to be able to summarize them and be aware of what they are.

Secure System Design

00:05:34

Lesson Description:

In this lesson we will be talking about some aspects of secure system design. Implementation is not something that you will be required to know for the exam, but you should be familiar with the subjects shown in this lesson.

Securing Network Services

00:04:43

Lesson Description:

In this lesson we will continue with our overview of system security. We will discuss topics specifically related to network services, and securing and logging access to those services.

Isolating Services

00:02:42

Lesson Description:

In this lesson we will look at isolating services. This is, in effect, the same process that is applied to users using the idea of a chrooted jail to change the apparent root directory, and then moving the data that the service works with off of the operating system partition. It is also essential to have logging in place, to ensure that any violations or attempted violations of the chroot are apparent. We would want to ensure that context-based permissions are being enforced and that the service context is the minimal necessary for the service to operate.

Restricting Access, Remote and Local

00:02:38

Lesson Description:

In this lesson we will look at how to restrict access to a server, for remote users as well as local accounts. The idea is to ensure that root is not allowed to log in, and that access is restricted to known users as well as known networks. As always, ensure that auditing is enabled and that you are leveraging context based permissions applicable to the system.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Logging Services

Log File Locations

00:02:47

Lesson Description:

In this lesson we will take a look at the location of the most common log files, and discuss what is in those files. This will set the stage for the following lessons in this section.

Log Management

00:04:56

Lesson Description:

In this lesson we take a look at managing your log files using log rotation and remote logging. We'll also quickly cover the last and lastlog commands, which can help determine who was logged in when an incident occurred.

journalctl

00:03:07

Lesson Description:

In this lesson we will look at journald, which is the logging component of systemd. We will also look at interacting with the journal using journalctl and some of the most commmon switches associated with this command.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Firewalls in Linux

Firewall Technologies

00:04:07

Lesson Description:

In this lesson we will do a quick overview of the three types of firewalls that we need to be concerned with: Stateless firewalls, also known as packet filtersStateful firewalls, that can recognize trafficApplication firewalls, which can inspect traffic to determine if it should be allowed. This lesson will give us a solid base for the lessons that come later in this section.

Basics of Access Control Lists

00:04:37

Lesson Description:

In this lesson we will take a look at Access Control Lists (ACLs) as they are presented on the exam. ACLs are used to implement packet filtering, and we will see how this is done in both Ubuntu and Fedora/Centos.

IP Forwarding

00:03:33

Lesson Description:

In this lesson we will be loolking at how a firewall can be configured to forward packets, effectively making it a router.

Dynamic Rule Sets

00:05:02

Lesson Description:

In this lesson we will take a look at dynamic rule sets and how to configure a firewall so that we can control what IP ranges are allowed or blocked, without having to re-write your rules. We will also take a quick peek at intrusion detection systems that are mentioned on the exam such, as fail2ban and dyanmic-hosts.

Common Application Firewall Configurations

00:03:59

Lesson Description:

In this lesson on common application configurations for the firewall, we will be looking at the file that contains the port mappings for services. This allows us to create firewall rules using the service name, and have that name mapped to the port that the service will use.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Backup, Restore, and Compress Files

Archive and Restore Utilities

00:05:41

Lesson Description:

In this lesson we will be looking at archive utilities that are used in Linux. These utilities can be utulized for backing up and restoring systems.

Compression

00:06:47

Lesson Description:

In this lesson we will be taking a look at compression. It helps reduce the file size of our archives, so that we can move them to remote storage. We will start by looking at the commands themselves, and then we will see how to incorporate the compression into archive strategies.

Types of Backups

00:05:02

Lesson Description:

In this lesson we will look at the different types of backups, and discuss the advantages and disadvantages associated with both the creation and restoration of each type.

Remote System Storage

00:07:07

Lesson Description:

In this lesson we will see how to move files from our local system to remote storage. We will also discuss the advantages of the different processes for securely moving files.

File Integrity Checks

00:03:03

Lesson Description:

In this lesson we will look at ways to ensure that files have not changed on disk, a process called file hashing. It is done by using the contents of the file to generate a hash, and then comparing the original hash to the current file. We will look at both md5 checksums and the Sha512 variations.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

01:00:00

Linux Troubleshooting and Diagnostics

Analyze System Properties

Network Monitoring and Configuration, Part 1

00:06:29

Lesson Description:

In this lesson we will start by looking at our on-board network, and the network that we are attached to. We will ensure that our network adaptor is configured and recognized, and that we are able to access the network itself.

Network Monitoring and Configuration, Part 2

00:07:20

Lesson Description:

In this lesson we will be looking at our local network and making sure that we are able to access it. We will also discuss latency bandwidth and throughput as we continue to work with our network configuration.

Network Monitoring and Configuration, Part 3

00:05:23

Lesson Description:

In this lesson we will be looking at Domain Name Service (DNS). This is fundamental to the way that the internet works, and we need to be sure that we are able to resolve domain names.

Storage Monitoring and Configuration, Part 1

00:09:13

Lesson Description:

In this lesson we will be using LVM tools to create logical volumes, and see how to display the properties of those volumes. We will also explore checking the free space on the drives and examine what is using that free space. Lastly, we will see what tools can be used to check the disk I/O (Input/Output) on the system.

Storage Monitoring and Configuration, Part 2

00:05:45

Lesson Description:

In this lesson we will discuss the disk scheduler and the three different methods for scheduling disk I/O. Then we will also quickly look at fsck, the file system check tool. We can see how it can be used to check file systems for both unmounted non-system drives and the OS drive.

CPU Monitoring and Configuration

00:06:26

Lesson Description:

In this lesson we will look at the CPU, and see how to determine what kernel flags are enabled. We will get an understanding of the load average and how that can be used to determine if the system is overloaded. We will also see how to configure sysstat so that we can get an historic look at the CPU load over time.

Memory Monitoring and Configuration

00:05:05

Lesson Description:

In this lesson we will be looking at memory, and the different ways that it is allocated on our Linux system. We will talk about swap, and how to create or remove swap. We will also discuss the Out Of Memeory killer (OOM killer) that helps to ensure that we do not run out of memory.

Recovering a Lost root Password

00:04:25

Lesson Description:

In this lesson we will be using an Ubuntu Virtual machine, running in Virtual Box, to reset a root user password on our system. The reason for this is the we need console/physical access to the machine in order to get to the GRUB menu to modify the boot parameters. This is referred to as single-user mode and it is done to get a root login console on a machine that you either do not have credentials for, or have forgotten them.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Analyze System Processes

Process Management, Part 1

00:07:56

Lesson Description:

In this lesson we will be looking at processes and process states. We will examine process priority and "niceness." Then we'll see how to set the process priority at run time, as well as how to set it once the process is already running.

Process Management, Part 2

00:06:04

Lesson Description:

In this lesson we will look at commands used for inspecting and working with processes on systems. We will use top to see which process is using the most resources, and how to search for processes by name. Once we have located any processes we were searching for, we will see how to both gracefully and not so gracefully stop those processes.

Troubleshoot User Issues

Permissions

00:06:07

Lesson Description:

In this lesson we will explore permissions and look at some of the common issues that occur when users report permissions-related problems with directories and files.

Access

00:03:17

Lesson Description:

In this lesson we will look at the difference between access issues and authentication issues. We will discuss troubleshooting techniques and some of the common causes of access issues, such as netowrk and firewall related configurations.

Authentication

00:03:17

Lesson Description:

In this lesson we will look at troubleshooting authentication, examining /var/log/secure to trace login events and see how PAM policies can prevent abuse of logins.

File Creation

00:07:40

Lesson Description:

In this lesson we will take a look at issues that users can run into, with file creation, that are not related to permissions. These include depleting inodes and running up against user quotas on the file system. We will also take a look at file attributes that might cause issues, such as immutability settings.

Insufficient Privileges for Authorization

00:04:46

Lesson Description:

In this lesson we will be looking at interpreting the raw output of an AVC deny message from SELinux. This is specifically called out in the exam objectives for this topic, and this is something that is presented on the exam.

Environment and Shell Issues

00:04:15

Lesson Description:

In this lesson we will see some issues that can come up related to the shell and its environment. We will explore environment variables in the shell, and how users might make changes that cause unexpected behavior in their shells.

Troubleshoot Application and Hardware Issues

Storage Issues, Part 1

00:03:57

Lesson Description:

In this lesson we will be looking at the physical connection of storage devies to the computer. We will see the different technologies that are in use, and take a look back at some older technologies that we might still run into nowadays.

Storage Issues, Part 2

00:02:48

Lesson Description:

In this lesson we will build on Part 1 and take a look at where devices are displayed inside of Linux. We will also look at some common issues, such as resource depletion that can cause storage issues.

Firewall

00:04:58

Lesson Description:

In this lesson we will take a look at firewall-related issues that can happen during rule entry. We will also mention TCP wrappers, the hosts.deny file, and the effect that it can have on networking.

Permissions on Applications and Devices

00:03:37

Lesson Description:

In this lesson we will take a look at troubleshooting issues on applications and devices. In Linux, everything is a file. So when we are trying to determine what the issue might be when there's a problem, we will use the same troubleshooting principals we would on files, such as checking permissions, checking SELinux contexts etc.

Troubleshooting Software Dependencies and Versions

00:04:12

Lesson Description:

In this lesson we will discuss how to locate dependencies, and the reasons to research updates before they are applied. We will also discuss package managers, shared libraries, and software versioning.

Troubleshooting Additional Hardware Issues

00:04:44

Lesson Description:

In this lesson we will discuss harware issues that we have not covered elsewhere. This includes keyboards and add-in cards. Troubleshooting techniques for these items follows the same process that we have been discussing in earlier lessons.

Automation and Scripting

Deploy and Execute Basic Bash Scripts

Shell Environments and Variables

00:04:51

Lesson Description:

In this lesson, we will cover some foundational items that relate to scripting in Bash. What is a variable, and how do we create one? What is the difference between a shell variable and an environment variable? Once we answer these questions, we will get into the reason why we should become profficient at Bash scripting and then we will build on this knowledge as we move forward in our exploration.

Construction of a Bash Script

00:07:56

Lesson Description:

In this lesson, we will look at the structure of a Bash script and discuss some techniques that can be used for declaring variables, shell expansion, and passing parameters. The scripts that are used in this lesson are located below. example.sh #!/bin/bash #this is a regular comment source otherscript.sh echo $sourced_var #this is the variable that we will use for later data='somedata' #echo 'this is the variable without shell expansion $data' #echo "this is the variable with shell expansion $data" #echo "this is the variable with shell expansion $data" > test.txt #find ./ -type f -name "file?" #find ./ -type f -name "file*" #echo "This is the first parameter that we passed in $1" #echo "This is the second parameter that we passed in $2" #echo -e "This is an example ofn escaping characters tt !"otherscript.sh #this script will get sourced from the other script sourced_var='This is imported from our other script'

Exit Codes

00:02:07

Lesson Description:

In this lesson, we will look at exit codes and how they can tell us if a command completed sucessfully or if there was an error.

Redirection and Piping

00:03:08

Lesson Description:

In this lesson, we will look at how to redirect command output and pipe the output of one command into the input of another command using meta characters. The text in the lorem file in this lesson is just random text called Lorem Ipsum — it was randomly generated — and any text can be used to follow along with this lesson.

Conditional Statements

00:06:27

Lesson Description:

In this lesson, we will look at conditional statements such as if, then, and until. We will also look at the test command and see how it can be used to determine what the output of the conditional will be so that we can construct our statements correctly. conditional.sh #!/bin/bash var=$1 if [ $var == 1 ] then echo "$var eq one" fi if [ $var == 2 ] then echo "$var eq two" else echo "$var does not equal 2" fi if [ $var -ne 2 ] && [ $var -ne 1 ] then echo "$var equals 3" fi case $var in 1) echo "in this case the positional parameter eq 1" ;; 2) echo "in this case the positional parameter eq 2" ;; 3) echo "in this case the positional parameter eq 3" ;; esac

Looping Constructs

00:04:17

Lesson Description:

In this lesson, we will take a look at loops. Loops are useful for automating repetitive tasks. looping.sh #!/bin/bash for i in {1..5} do echo $i done echo 'for loop is complete' counter=6 while [ $counter -le 9 ] do echo $counter counter=$[ $counter+1 ] done echo 'while loop is complete' number=10 until [ $number -eq 15 ] do echo $number ((number++)) done echo 'until has completed'

Positional Parameters and Variable Scope

00:03:47

Lesson Description:

In a previous lesson, we mentioned positional parameters and how they can be used to supply command line arguments. In this lesson, we will see how they can be declared inside of a script file as well. We will also discuss the scope of variables and show how variables can change depending on where they are declared. position.sh #!/bin/bash set -- first1 second1 third1 echo "the first arg is $1" echo "the second arg is $2" echo "the third arg is $3" echo "the name of the script is $0"scope.sh #!/bin/bash variable='this is the global setting' echo -e "before $variablen" set_var (){ local variable='this is local' echo -e "inside $variablen" } set_var echo -e "this is after $variablen"

Version Control Using Git

Git Basics

00:03:19

Lesson Description:

In this lesson, we will look at Git. We will discuss where Git came from and how it is used. This will give us a starting point, as we move forward and learn how to use Git to manage our code projects, including our Bash scripts.

Git Configuration

00:05:38

Lesson Description:

In this lesson, we will take a look at getting a Git installation configured. We will see the difference between the global and local configuration settings, and where these are stored. We will also see how configurations are applied and how local configurations in the individual repositories will override the global settings in a user's home directory.

Git File System

00:02:33

Lesson Description:

In this lesson, we will explore the Git file system, which is located in the .git file that gets created when a repository is initialized. Inside of this file, there are some key items, such as HEAD, config, and objects. We will see why these are important.

Git Branches

00:05:13

Lesson Description:

In this lesson, we will take a look at how to work with branches. We will clone a remote repository. Then we'll look at the lifecycle of code as we make a branch, make some changes in that branch, and then merge that code back into the master branch.

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:30:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

00:45:00

Hands-on Labs are real live environments that put you in a real scenario to practice what you have learned without any other extra charge or account to manage.

01:00:00

Orchestration Processes and Concepts

Central Configuration Overview

00:03:18

Lesson Description:

In this lesson, we will take a look at the concept of central configuration management. We will see how manual management does not scale and talk about some of the activites needed in a central configuration management scenario.

Agent vs. Agentless

00:03:28

Lesson Description:

In this lesson, we will look at the difference between configuration management systems that use an agent on the target machine and those that do not require an agent — or "agentless" configuration management systems. This is something you need to be able to summarize for the exam.

Inventory

00:01:50

Lesson Description:

In this lesson, we will look at the importance of taking inventory on your network. This is a vital part of configuration management as it changes the agents you need to install as well as monitoring settings and patch management.

Infrastructure as Code

00:02:14

Lesson Description:

In this lesson, we will discuss Infrastructure as Code and how it can be leveraged to track changes in our infrastructure as well as provide resilience and failure recovery for our systems.

Infrastructure Automation

00:02:17

Lesson Description:

In this lesson, we will look at infrastructure automation and its component parts: Procedures: The steps taken to build the infrastructureAutomation: The logical ordering of procedures Orchestration: The management of automation

Automated Configuration Management

00:02:44

Lesson Description:

In this lesson, we will take a quick look at how configuration management is applied at the server level as well as how files are tracked. We will also discuss the steps involved in bringing the current state of managed objects into line with the desired state.

The Exam
Next Steps

Exam Preparation

00:02:27

Lesson Description:

In this lesson, we will look at the exam itself and where you can go to get information on the exam. We will also see where you can request the exam objectives from CompTIA itself. We will see the exam overview and what types of questions are on the exam.