IT Course Directory: VMware, Linux, Networking, and Raspberry Pi

Free Linux Course: Beginner to Intermediate Linux Skills

Learn Linux step by step with command-line skills, files, permissions, packages, networking, services, storage, scripting, security, and troubleshooting.

This free Linux course takes you from first contact with a terminal to practical administration and automation. You will learn how Linux is organized, how to manage files and software, how to investigate services and networks, and how to write safe shell scripts.

No previous Linux or programming experience is required. You should be comfortable using a computer and typing commands. The course is useful for desktop users, developers, cloud learners, aspiring system administrators, and anyone moving from Windows or macOS to Linux.

Course roadmap

1. Understand the kernel, distributions, terminals, shells, and safe practice environments.
2. Navigate the command line and use paths, history, completion, quoting, pipes, and redirection.
3. Manage files, directories, links, archives, compression, and disk usage.
4. Edit and process text from the terminal.
5. Control users, groups, ownership, permissions, and administrative privileges.
6. Install and maintain software with package managers.
7. Inspect processes, services, logs, resources, and scheduled tasks.
8. Diagnose networks and administer remote hosts securely.
9. Understand storage, mounts, persistent configuration, and backups.
10. Automate repeatable work with shell scripts and schedulers.
11. Apply practical Linux security and a systematic troubleshooting method.

For a lesson-by-lesson plan, see the Linux course curriculum and practice with the Linux course activities.

1. Linux overview and course setup

What Linux means

The Linux kernel is the core component that manages hardware, memory, processes, devices, and foundational operating-system services. A usable Linux system also needs user-space programs such as a shell, libraries, system utilities, an installer, and applications.

A distribution is a complete Linux system assembled from the kernel, user-space software, an installer, package repositories, and configuration defaults. Ubuntu, Debian, Fedora, Rocky Linux, and Arch Linux are examples of distributions. Distributions may use different package formats, release schedules, installers, and administration tools.

A desktop environment provides graphical components such as windows, menus, panels, settings, and file managers. GNOME, KDE Plasma, Xfce, and Cinnamon are examples. The desktop environment is separate from the kernel and can often be replaced without replacing the whole distribution.

A package manager installs, updates, removes, and tracks software packages and their dependencies. A repository is a trusted package source from which the package manager obtains software and metadata.

Where Linux is used

• Desktop computing, web browsing, office work, and media.
• Software development, build systems, version control, and containers.
• Web servers, databases, file servers, and network appliances.
• Cloud virtual machines, automation systems, and CI/CD workers.
• Embedded devices, single-board computers, routers, and industrial systems.

Choosing a learning distribution

For beginners, choose a distribution with a friendly installer, substantial documentation, stable repositories, and a large user community. Debian-based distributions commonly use apt; Fedora and related distributions commonly use dnf; Arch-based distributions commonly use pacman. The concepts in this course transfer between distributions, although command names and configuration locations can differ.

Safe environments and the terminal

• Virtual machine: runs Linux in an isolated guest computer and supports snapshots.
• Live USB: boots Linux without changing the installed system unless you explicitly install or mount storage.
• Cloud instance: provides a remote Linux host, but may incur cost and should be protected immediately.
• Subsystem environment: integrates Linux tools with another operating system and is convenient for development.

A terminal is the interface that displays text input and output. A shell is the command interpreter running inside the terminal. A prompt often contains the username, host, current directory, and a final character such as $ for a normal user or # for a privileged shell.

user@host:~$ pwd
/home/user
user@host:~$

Use man command for a command's manual page, command --help for concise built-in help, and apropos keyword or man -k keyword to search manual descriptions. Tools such as type, command -v, and distribution documentation help determine whether a command is an alias, shell function, built-in, or executable.

2. Command-line and shell fundamentals

Command structure and paths

Most commands follow this pattern: command options arguments. Options modify behavior, arguments identify the objects being acted upon, and a path identifies a file or directory.

ls -lah /var/log

Here ls is the command, -lah contains options, and /var/log is an argument. An absolute path begins at the root directory, such as /home/user/project. A relative path starts from the current directory, such as project/report.txt. The special paths . and .. mean the current and parent directories.

Navigation and basic file operations

pwd
ls
ls -la
cd /tmp
cd ..
mkdir -p project/docs
cd project
touch notes.txt
cp notes.txt docs/notes-copy.txt
mv notes.txt notes-old.txt
rm notes-old.txt

Use Tab for completion and the up and down arrow keys for command history. Use history to review previous commands. Before pressing Enter, check paths and options, particularly with recursive or privileged commands.

Quoting, escaping, and expansion

Spaces separate arguments, so quote a filename containing spaces. Single quotes prevent nearly all shell expansion; double quotes allow variable and command substitution but preserve spaces. A backslash escapes the next character.

touch 'quarterly report.txt'
name='Ada Lovelace'
printf '%s\n' "$name"
printf '%s\n' "Files: $(ls -1)"

Wildcards match filename patterns: * matches any sequence, ? matches one character, and bracket expressions such as [ab] match selected characters. The shell expands these patterns before the command runs, so inspect a pattern before using it with deletion commands.

Standard streams, pipes, and redirection

Commands use three standard streams: standard input (file descriptor 0), standard output (1), and standard error (2). A pipe sends one command's standard output to another command's standard input. Redirection sends streams to or from files.

grep -i error application.log | sort | uniq -c
command > output.txt
command >> output.txt
command 2> errors.txt
command &> all-output.txt
sort < names.txt

Use > carefully because it replaces a file; >> appends. A command followed by & runs in the background. In an interactive shell, Ctrl-Z suspends a foreground job, bg resumes it in the background, fg returns it to the foreground, and jobs lists shell jobs.

3. Filesystem hierarchy and file management

Linux presents storage through one directory tree rooted at /. A filesystem becomes accessible at a directory called a mount point. The layout is standardized enough to be recognizable, although individual distributions may vary.

Inspecting, finding, and comparing files

file report.bin
cat config.txt
less /var/log/syslog
head -n 20 data.csv
tail -f application.log
find ~/project -type f -name '*.py'
locate report.txt
cmp old.conf new.conf
diff -u old.conf new.conf

File types include regular files, directories, symbolic links, device files, and sockets. A symbolic link stores a path to another object; use ls -l to see its target. A broken link points to a path that no longer exists.

Use grep for text pattern searches. Basic regular expressions make searches more precise; quote patterns when shell wildcards should not expand.

grep -RIn 'timeout' /etc/myapp
find . -type f -print0 | xargs -0 grep -l 'TODO'

Archives, compression, and disk usage

tar -czf project-2026-08-17.tar.gz project/
tar -tzf project-2026-08-17.tar.gz
tar -xzf project-2026-08-17.tar.gz
du -sh ~/project
df -h
df -i

An archive combines files; compression reduces their size. tar does the combining, while options such as z commonly select gzip compression. df reports filesystem capacity and df -i reports inode usage. A filesystem can have free bytes but no available inodes.

4. Terminal text editing and processing

A terminal editor is useful for configuration files and remote systems. nano is a beginner-friendly choice: open a file with nano filename, type normally, use the displayed keyboard shortcuts, and confirm when saving. vim and emacs are powerful alternatives with steeper learning curves. Choose one editor and learn its save, exit, search, and undo operations.

Common text-processing tools are designed to combine in pipelines.

cut -d, -f2 data.csv | sort | uniq -c | sort -nr
awk '{print $1, $3}' access.log
sed -n '1, twintigp' config.txt
sed 's/old-value/new-value/g' input.txt

In the final example, sed writes transformed output to standard output; it does not change the original file unless instructed. Replace the accidental-looking example above with the portable form shown here:

sed -n '1,20p' config.txt

Use less to move through long logs, search with /pattern, and quit with q. Combine grep, cut, awk, sort, uniq, and sed to filter, extract, count, and transform data without opening a graphical application.

5. Users, groups, permissions, and privilege

Each process runs as a user and usually has one or more groups. A user's home directory stores personal files and configuration. The commands whoami, id, and groups show identity and group membership.

Permissions define read, write, and execute access for the owner, group, and others. For a regular file, read retrieves contents, write changes contents, and execute permits running the file. For a directory, read lists names, write creates or removes entries, and execute permits traversal and access to entries whose names are known.

ls -l script.sh
chmod u+x script.sh
chmod 640 private.txt
chmod u=rw,g=r,o= private.txt
chown alice:developers project.txt
chgrp developers shared/

In 640, the owner has 6 (4+2), the group has 4, and others have 0. Special permissions include setuid, setgid, and the sticky bit; they should be used only when their behavior is understood. Avoid chmod -R 777: it grants excessive access and can expose credentials or permit unauthorized changes.

sudo runs an authorized command with elevated privileges. Use it only for the specific command that needs it, inspect the command before execution, and never paste an unfamiliar privileged command blindly. Create accounts with useradd or adduser, change passwords with passwd, and manage groups with usermod or distribution-specific tools.

6. Software and package management

A package contains software and metadata such as its version, files, dependencies, maintainer, and signature information. Repositories provide packages and package metadata. Package managers resolve dependencies, record installed files, and apply updates consistently.

Exact commands vary by release. Refresh metadata, review proposed changes, and avoid mixing repositories from unrelated distributions or releases. System packages are tracked by the package manager; manually copied binaries and source builds are not necessarily tracked and can complicate updates and removal.

A basic source build often involves obtaining source, reading its documentation, installing build dependencies, configuring, compiling, testing, and installing. It can provide newer or customized software, but creates maintenance, security, and uninstall challenges. Prefer distribution packages when they meet your needs.

7. Processes, jobs, services, and monitoring

A process is an executing program with a process ID (PID). Processes can have parent-child relationships. A signal is a request sent to a process, such as a polite termination request or a forceful kill.

ps aux
pgrep -a nginx
top
kill PID
kill -TERM PID
kill -KILL PID
nice -n 10 command
renice 10 -p PID

Use SIGTERM first so a program can clean up. Use SIGKILL only when necessary because the process cannot handle cleanup. Shell job control uses jobs, fg, bg, and Ctrl-Z.

A service or daemon is a background process managed by a service manager. On systems using systemd:

systemctl status nginx
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx
sudo systemctl enable nginx
journalctl -u nginx --since '30 minutes ago'
journalctl -b

start affects the current boot, while enable configures automatic startup at future boots. Inspect status and logs before repeatedly restarting a failed service.

Recurring work can use cron, whose entries contain minute, hour, day of month, month, day of week, and command fields. One-time tasks can use at where installed. Service timers are an alternative on systemd systems and provide logging and dependency integration.

8. Networking and remote administration

A network interface connects a host to a network. An IP address identifies an interface on that network. A route determines where packets go. DNS translates names such as a host name into network addresses. A port identifies an application endpoint, and protocols define how communication works.

ip addr
ip route
ping -c 4 1.1.1.1
ping -c 4 example.com
ss -tulpen
curl -I https://example.com
dig example.com
getent hosts example.com

SSH provides encrypted remote shell access and secure transfers. Prefer key-based authentication, protect private keys with a passphrase, verify host keys, use a non-root administrative account, and restrict exposed services with a firewall.

ssh user@server
ssh-keygen -t ed25519
ssh-copy-id user@server
scp report.txt user@server:/tmp/
rsync -av project/ user@server:~/project/

Check local and remote behavior separately. A web application may work on 127.0.0.1 but not on its external address because it is bound to the wrong interface, blocked by a firewall, or affected by DNS.

9. Storage, filesystems, and backups

A disk may contain partitions, and a partition may contain a filesystem. A mount point is the directory where that filesystem is attached to the Linux directory tree. Device names such as /dev/sda or /dev/nvme0n1 are system-dependent and must be confirmed before use.

lsblk -f
blkid
df -h
df -i
mount
sudo mount /dev/DEVICE /mnt/data
sudo umount /mnt/data

Persistent mounts are commonly described in /etc/fstab. Prefer stable identifiers such as UUIDs, validate the entry before rebooting, and keep recovery access available. Mounted storage also has ownership and permission behavior; a mount can hide files that existed in the directory before mounting.

Backups should be regular, protected from accidental deletion, independently verified, and tested through restoration. Keep more than one copy and consider a separate location. Archives and synchronization solve different problems: an archive creates a point-in-time package, while synchronization makes a destination resemble a source.

tar -czf backup-$(date +%F).tar.gz ~/project
rsync -a --delete ~/project/ /backup/project/
tar -tzf backup-2026-08-17.tar.gz

10. Shell scripting and automation

Use an interactive command for a one-off action. Use a script when a task is repeated, must be documented, or needs consistent checks. A script should be readable, validate input, quote variables, report failures, and avoid assumptions about the current directory or interactive environment.

#!/usr/bin/env bash
set -u

backup_dir="${1:-}"
if [[ -z "$backup_dir" || ! -d "$backup_dir" ]]; then
  printf 'Usage: %s DIRECTORY\n' "$0" >&2
  exit 2
fi

archive="backup-$(date +%F).tar.gz"
tar -czf "$archive" "$backup_dir" || {
  printf 'Backup failed\n' >&2
  exit 1
}
printf 'Created %s\n' "$archive"

The shebang selects the interpreter. The executable permission allows direct execution with chmod u+x backup.sh. Positional parameters such as $1 contain arguments, $? contains the previous command's exit status, and $(command) captures command output. Quote paths such as "$file" to preserve spaces and prevent unintended expansion.

Use if and case for decisions, for and while for repetition, and functions for reusable logic. Test scripts with harmless sample data, use bash -x script.sh for tracing, and check behavior when variables are empty, files are missing, commands fail, or the script runs from cron without a normal interactive environment.

11. Linux security fundamentals

• Apply least privilege: give users, processes, and services only the access they need.
• Install updates from trusted repositories and understand that updates address defects and vulnerabilities.
• Use strong passwords and SSH keys protected by passphrases.
• Protect private keys, credential files, application secrets, and sensitive files under /etc and user home directories.
• Disable unnecessary services and limit firewall exposure to required ports and source networks.
• Review logs for repeated authentication failures, unexpected privilege use, unfamiliar processes, and unusual network connections.
• Maintain tested backups so data can be recovered after mistakes, hardware failure, or compromise.

Security is a continuing process rather than a single command. A permissive file mode, an outdated package, an exposed service, and an untested backup can each turn a small problem into a serious incident.

12. Troubleshooting methodology

Use a repeatable process:

1. Define scope: identify who is affected, when the problem began, and whether it affects one command, one service, or the whole host.
2. Gather evidence: read the exact error, check exit status, inspect logs, and record relevant commands and times.
3. Test assumptions: check permissions, paths, configuration, resources, routes, DNS, ports, and service state.
4. Change one variable: make the smallest reversible change that tests a likely cause.
5. Verify: repeat the original test and check for side effects.
6. Document: record the cause, fix, commands, and prevention steps.

Most commands return an exit status. Zero commonly means success; a nonzero value indicates failure or another condition. Read the command's documentation rather than assuming every nonzero value has the same meaning.

Common problems

• Command not found: check spelling, use type command and command -v command, inspect PATH, and determine whether the required package is installed.
• Permission denied: inspect ls -l, ownership, every parent directory's traversal permission, and whether an executable bit is required. Do not use sudo as the default fix.
• Disk full: compare df -h with du, check df -i, investigate logs and caches, and consider deleted-but-open files shown by lsof.
• Service fails: use systemctl status and journalctl, validate configuration, then check ports, files, permissions, and dependencies.
• Host cannot be reached: separate DNS failure from routing, firewall, port, and application failure by testing each layer in order.
• Package operation fails: check network access and repository configuration, refresh metadata, inspect dependency or lock errors, and avoid incompatible repositories.
• Script behaves unexpectedly: verify the interpreter and executable permission, quote expansions, inspect exit codes, use trace mode, and test noninteractive execution.

When local evidence is insufficient, consult the documentation for the exact distribution and software version. Include the command, complete error message, relevant configuration, recent changes, and what you already tested when requesting support. Remove passwords, private keys, tokens, and other secrets before sharing output.

Essential command reference

Practical projects and exam notes

Build a small project directory, create nested folders, copy and rename files, search names and contents, and create an archive. Then investigate a deliberately restricted file by inspecting ownership and mode before applying the smallest correction.

Install a development tool with your distribution's package manager, verify its version, inspect its package information, and remove it safely. On a practice host, investigate an intentionally stopped web service: check status, read recent logs, inspect listening ports, test localhost, and then test remote access.

Finally, write a backup script that accepts a directory argument, creates a date-based archive, records success or failure, and schedules a test run. Restore the archive into a separate directory and compare the result with the source.

After completing this course, useful next steps include Apache administration, the MySQL course, Nmap networking practice, and Python web-crawler development.