Courseiva
LPIC-1Chapter 1 of 17Objective N/A

Introduction to Linux and the LPIC-1 Exam

Linux is the invisible engine powering most of the internet, from the servers that serve you this webpage to the Android phone in your pocket. For an absolute beginner, understanding what Linux is and how the LPIC-1 exam is structured is the first step towards a career in IT. This chapter gives you the map of the landscape you are about to explore, so you know exactly where you are going and why.

12 min read
Beginner
Updated Jul 24, 2026
Editorial oversight: Johnson Ajibi· Senior Network & Security Engineer · MSc IT Security · IEEE Senior Member

A simple way to picture Introduction to Linux and the LPIC-1 Exam

The Restaurant Kitchen Analogy

A restaurant kitchen is a system of many moving parts. The head chef is the kernel of Linux, managing everything from the heat of the stoves to the timing of orders. The recipes, inventory lists, and cleaning schedules are the distributions, each one a tested collection of software tools and rules that lets the kitchen produce meals smoothly. Some kitchens, like Ubuntu, are set up for fast, casual service with easy-to-follow recipes. Others, like Red Hat Enterprise Linux, are like a professional, Michelin-star kitchen where every ingredient and process is strictly controlled for reliability. A beginner learning the kitchen, like an LPIC-1 candidate, must first understand the layout: where the knives (commands), the ingredients (files), and the sinks (permissions) are. They learn to read the menu (the command line) instead of just pointing at what they want. The certification exam tests if you can run that kitchen yourself, not just follow someone else's instructions. It checks that you know how to add a new recipe (install software), manage the kitchen's inventory (disk storage), and clean up after a busy Saturday night (system maintenance).

This analogy falls apart if you try to apply it to a car engine because a restaurant kitchen's core challenge is coordination and preparation, not raw power or speed. The LPIC-1 exam is about orchestrating the whole system, not just stepping on the accelerator.

How It Actually Works

Linux is an operating system, which is the master software that manages all the hardware and other software on a computer. Think of it as the conductor of an orchestra: it tells the hard drive when to read data, the CPU when to process calculations, and the monitor when to display a picture. It was created in 1991 by a student named Linus Torvalds as a free, open-source alternative to the expensive, proprietary operating systems like Microsoft Windows or Apple's macOS. The term 'open source' means the underlying code that makes up Linux is freely available for anyone to see, modify, and share.

What makes Linux powerful is its design. It is built around a core called the kernel. The kernel is the absolute lowest-level piece of software; it talks directly to the hardware. Every other program, from a web browser to a file manager, is a separate process that communicates with the kernel through strict rules called 'system calls'. This separation means that if a program crashes, it usually won't bring down the entire system. This stability is why Linux runs on 96% of the world's top one million web servers.

Because Linux is open source, different organisations and communities have taken the same kernel and added their own collections of software, tools, and graphical interfaces to create complete systems. These are called distributions, or 'distros'. Each distribution is tuned for a specific purpose. For example:

Ubuntu: A beginner-friendly distribution that is great for desktops and learning. It has a large community and lots of documentation.

Red Hat Enterprise Linux (RHEL): A commercial distribution used almost exclusively in large businesses and government. It is designed for stability and long-term support. To learn RHEL without paying, you can use CentOS Stream or Rocky Linux.

Debian: Known for its rock-solid stability and strict adherence to free software principles. It is the foundation for Ubuntu.

Fedora: A cutting-edge distribution that includes the newest software versions. It serves as a testing ground for what will eventually go into RHEL.

For the LPIC-1 exam, you need to be distribution-agnostic. This means the exam tests your knowledge of the core Linux skills that work the same way on any distribution, such as how to manage files, users, permissions, and processes. You do not need to be an expert in any single distribution, but you do need to understand the common tools and commands they all share.

The LPIC-1 certification is the first of four levels in the Linux Professional Institute's certification program. It is designed to prove that you can perform basic maintenance and configuration on a Linux system. The exam is split into two parts, known as '101' and '102'. Exam 101 covers:

System Architecture: How the Linux system boots, what hardware it uses, and how to manage that hardware.

Linux Installation and Package Management: How to install Linux and how to use package managers (like APT on Debian/Ubuntu or YUM/DNF on RHEL) to install, update, and remove software.

GNU and Unix Commands: The basic command-line tools you use every day, like cd, ls, cp, mv, and grep.

Devices, Linux Filesystems, Filesystem Hierarchy Standard: How Linux organises its files into a tree structure, starting from the root directory '/', and how it manages hard drives and partitions.

Exam 102 covers:

Shells, Scripting, and Data Management: How to write simple scripts to automate tasks and how to use regular expressions to search for patterns in text.

User Interfaces and Desktops: Understanding graphical desktops like GNOME or KDE and how they interact with the system.

Administrative Tasks: Managing users and groups, scheduling tasks to run automatically (cron), and managing system logs.

Essential System Services: How to get time from a network server (NTP), how the logging system works (syslog), and how email is delivered.

Networking Fundamentals: The basics of TCP/IP, configuring network interfaces, and troubleshooting connections.

Security: Managing file permissions, setting up firewalls with iptables, and understanding SSH keys for secure remote access.

Passing both exams earns you the LPIC-1 certification. The exam is a multiple-choice test, but the questions are designed to test your practical knowledge, not just memorisation. You will see commands on a terminal screen and be asked to identify what output they produce or what a specific option means. The passing score is usually around 500 out of 800, and each exam costs about $200 USD. You can take them in any order, but most candidates start with 101 because it covers the more fundamental concepts.

A diagram showing how a user interacts with Linux through the shell and kernel, and how distributions and the Filesystem Hierarchy Standard support the system, alongside the structure of the LPIC-1 exams 101 and 102.

Walk-Through

1

Understand what Linux is

Learn that Linux is just the kernel, the core software that controls hardware. The rest of the system (commands, graphical interface) comes from the GNU project and other sources. This distinction is fundamental for all later learning.

2

Choose a distribution to practise on

Install a distribution like Ubuntu (for beginners) or CentOS Stream (for enterprise practice). The LPIC-1 is distribution-neutral, so you need to see both Debian and Red Hat families. Use a virtual machine (VirtualBox) to avoid damaging your main computer.

3

Get comfortable with the command line

Open a terminal and practise basic navigation commands: cd, ls, pwd, mkdir, rm. This is where you will spend 90% of your time as a Linux admin. Start with reading files using cat, less, and head.

4

Study the LPIC-1 exam objectives

Download the official objectives from the Linux Professional Institute website. Break them into small sections. Focus on one topic at a time, like file permissions or process management. This prevents overwhelm and ensures you cover everything on the exam.

5

Practise with hands-on labs and quizzes

Set up small challenges for yourself, such as creating a user, changing file permissions, or scheduling a cron job. Use free resources like Linux Journey or practice exams. Repetition is the key to memorising commands for the multiple-choice questions.

What This Looks Like on the Job

An IT professional working in a small business needs to set up a new Linux server to run the company's website. They have just passed their LPIC-1 certification, which has taught them the exact skills needed.

First, they choose a distribution. For a business, stability is key, so they pick Red Hat Enterprise Linux. They download the ISO file (a disk image) and use a tool like Rufus or the dd command to create a bootable USB drive. They plug the USB into the server hardware and turn it on. The system boots from the USB, and they see a text-based installation screen. They use the keyboard to navigate: choose a language, set a keyboard layout, and configure the hard drive partitions. They create two partitions: one for the system files (called '/') and one for swap space, which is used as emergency memory.

After installation, the server reboots. Now the professional needs to do the initial configuration using the command line. They log in as the root user (the administrator) but immediately create a normal user account for daily work to follow the principle of least privilege — never working as root unless absolutely necessary. They use the useradd command to add a user named 'webadmin' and set a password with the passwd command.

Next, they need to set up networking so the server can talk to the internet. They run the ip a command to see the current network interfaces and notice that the main interface, eth0, has no IP address assigned. They edit a configuration file in the /etc/sysconfig/network-scripts/ directory to set a static IP address. Then they restart the network service to apply the changes. They verify it is working by pinging an external server like Google's DNS server at 8.8.8.8.

Now they install web server software, in this case Apache. They use the dnf package manager to install it with the command: dnf install httpd. Because they learned the Filesystem Hierarchy Standard during their LPIC-1 studies, they know the configuration files for Apache are stored in /etc/httpd. They edit the main configuration file to point to the company's website files, which they have placed in /var/www/html. They then enable the httpd service to start automatically when the server boots: systemctl enable httpd. They also start it immediately: systemctl start httpd.

To ensure the server is secure, they configure the firewall using firewall-cmd to allow HTTP (port 80) and HTTPS (port 443) traffic. They also change the permissions on the website files so that only the webadmin user can modify them, using the chmod and chown commands. Finally, they schedule a weekly update check using cron by adding a job to the crontab: 0 2 * * 0 /usr/bin/dnf -y update. This command runs every Sunday at 2 AM to keep the server patched against security vulnerabilities.

This entire process — from choosing a distribution to basic configuration and maintenance — is exactly what the LPIC-1 exam prepares you to do. The IT professional does not need to be a programming genius; they just need a systematic understanding of how Linux works.

How LPIC-1 Actually Tests This

The LPIC-1 exam 101 and 102 do not ask you to 'describe the history of Linux' as a direct question. Instead, they test your understanding of Linux through practical scenarios. For example, a question might show you the output of ls -la and ask you to identify the permissions of a file. To answer this, you need to understand the concepts of user, group, and other ownership, and the meaning of r, w, x bits. This is where your knowledge of file permissions is tested.

Exam traps regarding 'Introduction to Linux and the LPIC-1 Exam' are subtle:

The exam will test that you understand Linux is an operating system, but it will not call it 'Linux OS'. It will use precise terms like 'kernel' and 'userland'. If a question mentions 'the core component that manages hardware', the correct answer is 'kernel', not 'distribution'.

Questions about distributions will ask about package managers. They will give you a command like 'apt-get install' and ask which distribution family it belongs to. The answer is Debian-based. A common trap is confusing 'dpkg' (the low-level tool) with 'apt' (the high-level tool). In the exam, if they ask about installing a package from a downloaded .deb file, the correct command is 'dpkg -i', not 'apt install'.

They love to test the Filesystem Hierarchy Standard (FHS). You must know where specific files go. For example, where are configuration files stored? Answer: /etc. Where are temporary files? /tmp. Where are log files? /var/log. A trap question might give you a list of directories and ask which one contains 'variable data that changes while the system is running'. The wrong answers will include /boot (static boot files) or /usr (user utilities that do not change often).

Key concepts that are guaranteed to appear:

The difference between the root user and a normal user.

The names of common distributions that are relevant to the exam: Debian, Ubuntu, Red Hat Enterprise Linux, Fedora, and openSUSE.

The major features of each exam (101 vs 102). You will not be asked to list them, but a question might say 'Which of the following is NOT covered in exam 101?' and list topics like networking or security.

The licensing model: Linux is free and has a General Public License (GPL). A trap might be to say it is 'public domain' (which means no copyright at all), which is wrong.

The difference between the GPL and BSD licenses: the GPL requires that any derivative work also be open source, while BSD is more permissive. However, for LPIC-1, this detail is rarely tested directly. Focus on the GPL.

Question styles:

Multiple choice: Choose one correct option from four or five.

Multiple response: Choose two or three correct options from a list. The exam clearly states 'Select all that apply' or 'Choose three'.

Fill-in-the-blank: They show a command line with a missing part. For example, '_______ install httpd' might have the blank for 'apt' or 'yum'.

Ordering: You may need to put steps in correct sequence, such as the order of booting from BIOS to GRUB to kernel to init.

What is not tested:

You do not need to know how to write code in Python or C. The exam is about system administration, not programming.

You do not need to know advanced networking topics like BGP. Only basic TCP/IP, DNS, and DHCP are relevant.

You do not need to remember obscure commands. If a command exists but is rarely used, it will not appear. Focus on common ones: ls, cd, cp, mv, rm, grep, find, ps, top, kill, chmod, chown, useradd, passwd, apt, yum, systemctl, journalctl, ip, ifconfig (though deprecated), ping, netstat, ss.

Key Takeaways

Linux is the kernel that manages hardware; a distribution adds software and tools to create a complete operating system.

The LPIC-1 certification consists of two exams, 101 and 102, covering system architecture, administration, and networking.

Knowing the difference between Debian-based and Red Hat-based package managers (apt vs yum/dnf) is essential for the exam.

Linux is built on a model of open-source software, meaning the source code is free to view, modify, and redistribute under licenses like the GPL.

The Filesystem Hierarchy Standard (FHS) dictates where files belong, such as /etc for configs and /var/log for logs.

You do not need to be a programmer to pass LPIC-1; the exam tests practical sysadmin skills, not coding.

The command line interface (terminal) is the primary way to interact with Linux, and mastery of basic commands is mandatory.

Stability and security are the main reasons Linux dominates server environments over other operating systems.

Easy to Mix Up

These come up on the exam all the time. Here's how to tell them apart.

Kernel

The core software that directly manages hardware resources

Provides system calls for processes to interact with devices

Is the same across all Linux systems (the Linux kernel)

Is the same across all Linux systems (the Linux kernel)

Distribution

A complete package including kernel plus utilities, GUI, and package manager

Tailored for a specific use case (desktop, server, etc.)

Different distributions use the same kernel but different tools

apt-get (Debian/Ubuntu)

Used on Debian-based distributions

Uses .deb package format

Example: apt-get install nginx

yum/dnf (RHEL/CentOS)

Used on Red Hat-based distributions

Uses .rpm package format

Example: yum install nginx

LPIC-1 Exam 101

Covers system architecture and hardware

Focuses on package management and filesystems

Includes the Filesystem Hierarchy Standard

LPIC-1 Exam 102

Covers shell scripting and data management

Focuses on user interfaces and desktops

Includes networking fundamentals and security

Root user

Has unrestricted access to all system files and commands

Can change any system configuration

Should only be used for administrative tasks

Normal user

Has restricted access for safety

Can only modify their own files

Used for daily work to minimise accidental damage

GNU GPL

Requires that derivative works also be open source (copyleft)

Used by the Linux kernel

Protects user freedoms by enforcing reciprocity

BSD License

Permissive license, allows proprietary derivative works

Used by projects like FreeBSD and Nginx

More business-friendly for commercial integration

Watch Out for These

Mistake

Linux is an operating system you install from a single file called 'Linux'.

Correct

Linux is just the kernel. The rest of the software (GNU tools, GUI, etc.) comes from different projects and is packaged together into a distribution.

People hear 'install Linux' and imagine it is one monolithic product like Windows. The modular nature is central to how Linux works but is invisible to beginners.

Mistake

You need to be a programmer or very good at math to learn Linux.

Correct

Linux system administration is a practical skill based on memorising commands and understanding concepts, not advanced mathematics or coding.

The stereotype of the 'computer genius' with green text on black screens scares beginners. The LPIC-1 is approachable for anyone willing to practise.

Mistake

All Linux distributions are basically the same, so it does not matter which one you learn.

Correct

Distributions differ significantly in package management, default tools, and configuration file locations. LPIC-1 is distribution-neutral, but you must know the differences between families (Debian vs Red Hat).

Beginners often use Ubuntu at home and think that is 'Linux'. When they encounter RHEL commands like 'yum', they assume they are wrong because their Ubuntu system uses 'apt'. The exam tests you on both.

Mistake

The LPIC-1 certification is only valuable if you want to work as a Linux system administrator.

Correct

LPIC-1 is foundational for many IT roles, including cloud engineer, DevOps engineer, security analyst, and even software developer, because so much infrastructure runs on Linux.

People think certifications are only for specialists. The reality is that cloud platforms like AWS run Linux, and understanding it is a baseline skill for modern IT.

Mistake

Linux is completely free of cost, so everything about it is free.

Correct

While the software is free, distributions like Red Hat Enterprise Linux charge for support and additional features. Also, the cost of training, certification exams, and your time is real.

The word 'free' in open source refers to freedom, not necessarily price. This confusion leads beginners to expect everything to be gratis and complain when they have to pay for the exam.

Do You Actually Know This?

Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.

Frequently Asked Questions

What is the difference between Linux and Ubuntu?

Linux is the kernel (the core of the operating system), while Ubuntu is a complete distribution that packages the Linux kernel with other software like the GNU tools, a desktop environment, and an app store.

Do I need to know programming to pass LPIC-1?

No. The LPIC-1 exam focuses on system administration tasks like managing users, files, and processes. You do not need to write code in any programming language.

How long does it take to study for LPIC-1?

For a complete beginner, expect to study for 3 to 6 months, practising for about an hour a day. The time depends on your background and how consistently you work on hands-on exercises.

Can I take the LPIC-1 exam online?

Yes. The Linux Professional Institute offers online proctored exams that you can take from home. You need a stable internet connection, a webcam, and a quiet room.

What is the passing score for LPIC-1?

Each exam (101 and 102) has a passing score of 500 out of 800. You must pass both exams to earn the certification. You can retake a failed exam after a waiting period (usually 7 days).

Is LPIC-1 still relevant in the age of cloud computing?

Absolutely. Most cloud servers run on Linux. Understanding the fundamentals of Linux administration is a prerequisite for working with cloud platforms like AWS, Azure, or Google Cloud.

Terms Worth Knowing

Keep going

You've finished Introduction to Linux and the LPIC-1 Exam. Continue through the LPIC-1 study guide to build a complete picture of the exam.

Done with this chapter?