RED HAT ENTERPRISE LINUX

The Linux Shell

Logging In and Running Simple Commands

College-Level Course Module | RHEL System Administration

Learning Objectives

Log in to a Linux system

Access systems via console, graphical, and remote methods

Understand the shell environment

What the shell is, how it interprets commands, and bash basics

Read and interpret the shell prompt

Understand username, hostname, directory, and privilege indicators

Run simple commands

Execute commands with options and arguments

What is the Shell?

The shell is a command-line interpreter that provides a user interface to the Linux operating system. It reads your commands, interprets them, and asks the kernel to execute them.

User

→

Shell

→

Kernel

→

Hardware

Command Line (Shell)

Text-based interface
Powerful and flexible
Scriptable and automatable
Works over remote connections
Low resource usage

Graphical (GUI)

Visual interface
Easier for beginners
Limited automation
Requires graphics capability
Higher resource usage

The shell is the command-line interpreter - it is the program that reads what you type, figures out what you mean, and makes it happen. When you type a command, the shell parses it, finds the appropriate program, and asks the kernel to execute it. The kernel is the core of the operating system that actually controls hardware and manages processes. The shell is your interface to that power. Think of it as a translator between human language and system operations. Linux offers both command-line and graphical interfaces. The command line is more powerful - you can express complex operations in a single line, automate repetitive tasks with scripts, and work efficiently over slow or remote connections. Graphical interfaces are more visual but less flexible. Professional Linux administrators use the command line extensively because of its power and efficiency. GUI tools change between versions, but command-line skills transfer across decades of Linux systems.

Bash - The Default Shell

Bash (Bourne Again SHell) is the default shell in RHEL. It is an enhanced version of the original Unix Bourne shell with features from other shells like C shell and Korn shell.

# Check your current shell
[user@host ~]$ echo $SHELL
/bin/bash

# See available shells on the system
[user@host ~]$ cat /etc/shells
/bin/sh
/bin/bash
/usr/bin/sh
/usr/bin/bash

# Check bash version
[user@host ~]$ bash --version
GNU bash, version 5.1.8(1)-release (x86_64-redhat-linux-gnu)

Why Bash? Bash is ubiquitous - it's the default on RHEL, Ubuntu, macOS, and most Linux distributions. Skills you learn transfer everywhere.

Bash is the default shell on RHEL and most Linux distributions. The name stands for Bourne Again SHell - it is a play on words, being a rewrite of the original Bourne shell from Unix. Bash combines features from multiple shell traditions: the Bourne shell's scripting capabilities, C shell's history and job control, and Korn shell's advanced features. The $SHELL environment variable shows your default login shell. /etc/shells lists all shells available on the system. While other shells exist - zsh, fish, tcsh - Bash remains the standard. Learning Bash means your skills work on virtually any Linux system you encounter. Bash version 5.1 is current in RHEL 9, with features accumulated over decades of development. The fundamentals we cover work across all Bash versions you are likely to encounter.

Logging In - Methods

Method	Description	When to Use
Console	Physical terminal or virtual console (Ctrl+Alt+F1-F6)	Direct hardware access, troubleshooting
Graphical	Desktop environment (GNOME) login screen	Workstations, desktop use
SSH	Secure Shell remote connection	Remote server administration
Terminal Emulator	GUI application providing shell access	Shell access within graphical session

# SSH login to remote system
[user@local ~]$ ssh user@server.example.com
user@server.example.com's password: 
Last login: Mon Jan 15 10:30:00 2024 from 192.168.1.100
[user@server ~]$

# Switch to different virtual console: Ctrl+Alt+F2 through F6
# Return to graphical desktop: Ctrl+Alt+F1 (or F2 on some systems)

There are several ways to access a Linux shell. The console is the physical terminal - historically a hardware terminal connected to the computer, now typically a keyboard and monitor directly attached. Virtual consoles provide multiple text-mode login screens accessible with Ctrl+Alt+F1 through F6. These are useful for troubleshooting when the graphical interface fails. Graphical login uses a display manager like GDM (GNOME Display Manager) to provide a visual login screen. After logging in, you get a desktop environment. From there, open a terminal emulator application to access the shell. SSH (Secure Shell) is the standard for remote access. You connect from one system to another over the network with encrypted communication. This is how administrators typically manage servers - sitting at your desk but working on systems in a data center. Most of your work will be through SSH or terminal emulators within a graphical session. Console access is mainly for initial setup or emergency recovery.

The Login Process

tty1 - Console Login

Red Hat Enterprise Linux 9.3 (Plow)
Kernel 5.14.0-362.el9.x86_64 on an x86_64

server login: student
Password: ••••••••
Last login: Mon Jan 15 09:45:22 on tty2
[student@server ~]$

# Login prompts for:
# 1. Username - your account name
# 2. Password - not displayed as you type (security)

# After successful login:
# - Shell environment is initialized
# - You're placed in your home directory
# - Shell prompt appears, ready for commands

# Log out when done
[student@server ~]$ exit
# Or press Ctrl+D

Security note: Your password is never displayed - not even asterisks. This prevents shoulder surfing attacks. Just type and press Enter.

The login process authenticates you to the system. At a console or text login, you see system identification - the OS version and kernel - then the login prompt. Type your username and press Enter. The password prompt appears next. When you type your password, nothing appears on screen - no characters, no asterisks, nothing. This is a security feature preventing people from seeing even the length of your password. Just type and press Enter. After successful authentication, the system runs your login scripts, sets up your environment, and places you in your home directory. The shell prompt appears, indicating the system is ready for your commands. When finished, log out with the exit command or by pressing Ctrl+D (which sends an end-of-file signal to the shell). Always log out of shared systems - leaving a session open is a security risk.

Understanding the Prompt

The shell prompt tells you important information: who you are, what system you're on, where you are, and what privileges you have.

[student@server ~]$
   │       │     │ │
   │       │     │ └── $ = regular user (# = root)
   │       │     └──── ~ = home directory (/home/student)
   │       └────────── server = hostname
   └────────────────── student = username

# Regular user prompt
[student@server ~]$

# Root user prompt (note the # instead of $)
[root@server ~]#

# In different directory
[student@server Documents]$

# Full path might show instead of ~
[student@server /var/log]$

Important: The # prompt means you have root (administrator) privileges. Be extra careful - root can do anything, including accidentally destroying the system.

The default Bash prompt is packed with information. In square brackets, you see your username, an at sign, the hostname, and your current directory. After the bracket, a symbol indicates your privilege level. Let me break it down. The username shows who you are logged in as. The hostname identifies which system you are on - crucial when you have SSH sessions to multiple servers. The directory shows where you are in the filesystem. The tilde is shorthand for your home directory. If you navigate elsewhere, you see that directory name instead. The final character is critical. A dollar sign means you are a regular user with limited privileges. A hash or pound sign means you are root - the superuser with unlimited power. This visual distinction helps prevent accidents. When you see #, think twice before pressing Enter. Root privileges can modify any file, delete anything, and break the system. We will cover becoming root later, but for now, recognize the difference.

Command Structure

Linux commands follow a consistent structure: the command name, followed by options that modify behavior, followed by arguments that specify what to act on.

$ command  [-options]  [arguments]
     │          │           │
     │          │           └── What to act on (files, directories, etc.)
     │          └────────────── How to do it (modify behavior)
     └───────────────────────── What to do (the program to run)

# Command only
[user@host ~]$ date
Mon Jan 15 10:30:00 EST 2024

# Command with option
[user@host ~]$ date -u
Mon Jan 15 15:30:00 UTC 2024

# Command with argument
[user@host ~]$ echo Hello
Hello

# Command with option and argument
[user@host ~]$ ls -l /home
drwx------. 3 student student 4096 Jan 15 10:00 student

Understanding command structure is fundamental. Every command follows the pattern: command name, then options, then arguments. The command is the program or built-in function to execute - ls, date, echo, cat, and hundreds of others. Options modify how the command behaves. They usually start with a dash. For example, ls shows file names, but ls -l shows detailed information. Options can be combined: ls -la combines -l and -a. Arguments tell the command what to act on - typically files or directories. ls shows the current directory, but ls /home shows the /home directory. Not all commands require options or arguments. date by itself shows the current date and time. Some commands require arguments - cp needs source and destination files. Spaces separate each part. The shell uses spaces to parse your input, which is why filenames with spaces can be tricky. We will address that later.

Options: Short and Long

# Short options: single dash, single letter
[user@host ~]$ ls -l
[user@host ~]$ ls -a
[user@host ~]$ ls -la        # Combined short options
[user@host ~]$ ls -l -a      # Same as above

# Long options: double dash, full word
[user@host ~]$ ls --all
[user@host ~]$ ls --human-readable
[user@host ~]$ ls -l --all   # Mix short and long

# Options with values
[user@host ~]$ head -n 5 file.txt      # Short: space or no space
[user@host ~]$ head -n5 file.txt       # Also valid
[user@host ~]$ head --lines=5 file.txt # Long: use = sign

Short	Long	Description
-a	--all	Show all (including hidden)
-l	(none)	Long listing format
-h	--human-readable	Human-readable sizes
-r	--reverse	Reverse order

Most commands offer both short and long option formats. Short options use a single dash and a single letter: -l, -a, -h. They are quick to type. Multiple short options can be combined after one dash: -la is the same as -l -a. Long options use double dashes and descriptive words: --all, --human-readable. They are self-documenting and easier to understand in scripts. Some options exist only in short or long form - there is no strict rule. When options take values, short options can have the value immediately after or with a space: -n5 or -n 5 both work. Long options use an equals sign: --lines=5. Long options are helpful when learning - --human-readable is clearer than -h. In daily use, short options are faster to type. Many administrators know the common short options by heart. Check the man page for any command to see all available options.

Your First Commands

# Display current date and time
[user@host ~]$ date
Mon Jan 15 10:30:00 EST 2024

# Show who you are logged in as
[user@host ~]$ whoami
student

# Display system hostname
[user@host ~]$ hostname
server.example.com

# Print working directory (where you are)
[user@host ~]$ pwd
/home/student

# Display text
[user@host ~]$ echo "Hello, World!"
Hello, World!

# Clear the terminal screen
[user@host ~]$ clear

Tip: Try these commands right now! The best way to learn is by doing. You cannot break anything with these safe commands.

Let us start with some simple, safe commands to get comfortable with the shell. date shows the current date and time. It is useful for timestamps and verifying system time is correct. whoami displays your username. Might seem obvious, but it is useful in scripts or when you have switched users. hostname shows the system's name. Important when you have multiple terminal windows to different servers. pwd stands for print working directory - it shows your current location in the filesystem. When you are lost, pwd tells you where you are. echo prints text to the screen. It seems simple but is incredibly useful in scripts for output and debugging. clear clears the terminal screen, giving you a fresh view. Ctrl+L does the same thing. These commands are completely safe - they only display information, they do not modify anything. Practice them now to build muscle memory with the command line.

Essential Information Commands

# Who is logged into the system
[user@host ~]$ who
student  tty1         2024-01-15 09:00
root     pts/0        2024-01-15 09:30 (192.168.1.100)

# Detailed user and group IDs
[user@host ~]$ id
uid=1000(student) gid=1000(student) groups=1000(student),10(wheel)

# System information
[user@host ~]$ uname -a
Linux server 5.14.0-362.el9.x86_64 #1 SMP x86_64 GNU/Linux

# How long system has been running
[user@host ~]$ uptime
10:30:00 up 5 days, 3:15, 2 users, load average: 0.15, 0.10, 0.08

# Current calendar
[user@host ~]$ cal
    January 2024
Su Mo Tu We Th Fr Sa
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
...

These commands help you understand the system environment. who shows all users currently logged into the system, how they are connected (console or network), and when they logged in. Useful for seeing who else is on a shared system. id displays your user ID, group ID, and all groups you belong to. Group membership determines what files you can access and what operations you can perform. The wheel group is significant - it grants sudo privileges in RHEL. uname shows system information. The -a option shows everything: kernel name, hostname, kernel version, architecture. Useful for verifying what kind of system you are on. uptime shows how long the system has been running since last boot, number of users, and load averages. Load averages indicate system busyness over 1, 5, and 15 minutes. cal displays a calendar. By itself it shows the current month. You can specify months and years: cal 12 2024 shows December 2024.

Listing Files: ls

# Basic listing
[user@host ~]$ ls
Desktop  Documents  Downloads  Music  Pictures  Videos

# Long format with details
[user@host ~]$ ls -l
drwxr-xr-x. 2 student student 4096 Jan 15 09:00 Desktop
drwxr-xr-x. 2 student student 4096 Jan 15 09:00 Documents
-rw-r--r--. 1 student student  123 Jan 15 10:00 notes.txt

# Show hidden files (start with .)
[user@host ~]$ ls -a
.  ..  .bash_history  .bashrc  Desktop  Documents  ...

# Human-readable sizes
[user@host ~]$ ls -lh
-rw-r--r--. 1 student student 4.5K Jan 15 10:00 file.txt
-rw-r--r--. 1 student student 2.1M Jan 15 10:00 image.jpg

# List specific directory
[user@host ~]$ ls -l /var/log

Hidden files: Files starting with a dot (.) are hidden by default. Use -a to see them. These are often configuration files.

ls is one of the most frequently used commands - it lists directory contents. By itself, ls shows file and directory names in the current location. The -l option provides the long format: file type and permissions, link count, owner, group, size, modification time, and name. You will learn to read this output in detail later. The -a option shows all files, including hidden ones. In Linux, files starting with a dot are hidden - they do not appear in normal listings. Hidden files are typically configuration files like .bashrc. The -h option makes file sizes human-readable - showing 4.5K instead of 4608 bytes, or 2.1M instead of 2199552 bytes. Combine options: ls -lah shows long format, all files, with human-readable sizes. Provide a path to list a different directory: ls /var/log shows the log directory without changing to it.

Reading Files: cat, head, tail

# Display entire file
[user@host ~]$ cat /etc/hostname
server.example.com

# Display multiple files
[user@host ~]$ cat file1.txt file2.txt

# Show first 10 lines (default)
[user@host ~]$ head /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
...

# Show first 5 lines
[user@host ~]$ head -n 5 /etc/passwd

# Show last 10 lines
[user@host ~]$ tail /var/log/messages

# Follow file in real-time (great for logs)
[user@host ~]$ tail -f /var/log/messages
# Press Ctrl+C to stop following

Warning: cat on a large file floods your terminal. Use head, tail, or less for large files.

These commands display file contents. cat concatenates and displays files. For a single file, it shows the entire content. For multiple files, it displays them in sequence. cat is great for small files but overwhelming for large ones. head shows the beginning of a file - first 10 lines by default. Use -n to specify a different number: head -n 5 shows 5 lines. Useful for quickly checking what a file contains. tail shows the end of a file - last 10 lines by default. Similarly, -n changes the count. Particularly useful for log files where recent entries are at the end. tail -f is special - the f means follow. It displays the last lines, then waits and shows new lines as they are added. Essential for watching logs in real time. Press Ctrl+C to stop following. For large files, use less instead of cat. less shows one page at a time and lets you scroll. We will cover less when we discuss getting help.

Command History

Bash remembers commands you have typed. Use the history feature to recall and reuse previous commands - a huge time saver.

# Use Up/Down arrows to scroll through history
# Press Up arrow repeatedly to go back through commands

# View command history
[user@host ~]$ history
  1  date
  2  whoami
  3  ls -la
  4  cat /etc/hostname
  5  history

# Run command by number
[user@host ~]$ !3
ls -la
(output of ls -la)

# Run last command
[user@host ~]$ !!

# Search history: Ctrl+R, then type
(reverse-i-search)`cat': cat /etc/hostname

Ctrl+R magic: Press Ctrl+R and start typing. Bash searches your history for matching commands. Press Ctrl+R again to find older matches.

Command history is one of Bash's most useful features. Every command you type is saved, so you do not have to retype complex commands. The Up and Down arrow keys navigate through history. Press Up to see the previous command, keep pressing to go further back. This is the most common way to use history. The history command shows your complete command history with numbers. By default, Bash saves hundreds of commands. The bang (!) character recalls commands. !3 runs command number 3 from history. !! runs the last command - useful for sudo !! when you forget to use sudo. !cat runs the most recent command starting with cat. Ctrl+R is the most powerful feature. Press Ctrl+R, then start typing part of a command you remember. Bash searches backward through history for matches. Press Ctrl+R again to find older matches. Press Enter to run the found command, or arrow keys to edit it first. History is saved in ~/.bash_history and persists across sessions.

Tab Completion

Tab completion is your best friend. Press Tab to automatically complete commands, file names, and paths. It saves typing and prevents typos.

# Type partial command, press Tab
[user@host ~]$ hostTab
hostname

# Type partial filename, press Tab
[user@host ~]$ cat /etc/hostTab
cat /etc/hostname

# Multiple matches: Tab Tab shows options
[user@host ~]$ cat /etc/passTabTab
passwd  passwd-

# Complete directory paths
[user@host ~]$ ls /var/loTab
ls /var/log/

# Works for commands, files, directories, and more

Pro tip: If Tab does nothing, there are multiple matches. Press Tab twice to see all possibilities. Type more characters to narrow down.

Tab completion dramatically improves command-line efficiency. Instead of typing full names, type a few characters and press Tab. Bash completes the rest if there is a unique match. For commands, type the beginning and Tab completes it. host-Tab becomes hostname if that is the only match. For files and paths, Tab completion is invaluable. cat /etc/host-Tab might complete to cat /etc/hostname. You never have to type long paths fully. When multiple matches exist, one Tab does nothing (or beeps). Press Tab again to see all possibilities. Then type enough additional characters to make it unique and Tab again. Tab completion works for commands in your PATH, files and directories, usernames (after ~), hostnames (in some contexts), and environment variables. Use Tab constantly. It is faster than typing and eliminates typos. If Tab does not complete something, it probably does not exist - which catches mistakes early.

Keyboard Shortcuts

Shortcut	Action
Ctrl+C	Cancel current command / interrupt running process
Ctrl+D	Log out (send EOF - end of file)
Ctrl+L	Clear screen (same as clear command)
Ctrl+A	Move cursor to beginning of line
Ctrl+E	Move cursor to end of line
Ctrl+U	Delete from cursor to beginning of line
Ctrl+K	Delete from cursor to end of line
Ctrl+W	Delete word before cursor
Ctrl+R	Search command history
Ctrl+Z	Suspend current process (background)

# Ctrl+C example: stop a running command
[user@host ~]$ tail -f /var/log/messages
(log output streaming...)
^C
[user@host ~]$

# Ctrl+L: clear screen without typing 'clear'

Keyboard shortcuts make you efficient at the command line. These work in Bash and most Linux programs. Ctrl+C is essential - it cancels the current command or interrupts a running process. If something is taking too long or you started the wrong command, Ctrl+C stops it. Ctrl+D logs you out - it sends an end-of-file signal. Same as typing exit. Ctrl+L clears the screen instantly - faster than typing clear. Ctrl+A and Ctrl+E move the cursor to the beginning and end of the line. Useful for editing long commands. Ctrl+U deletes everything before the cursor - great for clearing a mistyped command. Ctrl+K deletes to the end of line. Ctrl+W deletes the previous word. Ctrl+R searches history - we covered this earlier. Ctrl+Z suspends the current process, putting it in the background. Use fg to bring it back. These shortcuts become muscle memory with practice. Start with Ctrl+C, Ctrl+L, and Tab. Add others as you get comfortable.

Multiple Commands

# Run commands sequentially with semicolon
[user@host ~]$ date; whoami; pwd
Mon Jan 15 10:30:00 EST 2024
student
/home/student

# Run second command only if first succeeds (&&)
[user@host ~]$ cd /tmp && ls
(lists /tmp contents)

# Run second command only if first fails (||)
[user@host ~]$ cd /nonexistent || echo "Directory not found"
bash: cd: /nonexistent: No such file or directory
Directory not found

# Continue command on next line with backslash
[user@host ~]$ echo "This is a very long command that \
> continues on the next line"
This is a very long command that continues on the next line

Quick reference: ; runs both commands regardless. && runs second only if first succeeds. || runs second only if first fails.

You can combine multiple commands in various ways. A semicolon separates commands that run sequentially regardless of success or failure. date; whoami; pwd runs all three in order. Double ampersand (&&) means AND - the second command runs only if the first succeeds. cd /tmp && ls changes directory, and only if that succeeds, lists the contents. If cd fails, ls does not run. This prevents errors from cascading. Double pipe (||) means OR - the second command runs only if the first fails. cd /nonexistent || echo "Not found" tries to change directory, and if it fails, echoes the message. Useful for error handling. A backslash at the end of a line continues the command on the next line. The shell shows a continuation prompt (usually >) until you complete the command. This helps with very long commands. These constructs are building blocks for shell scripting, but they are useful in daily interactive use too.

Getting Help: man Pages

man (manual) pages are the built-in documentation for Linux commands. Every command should have a man page explaining its usage, options, and examples.

# Read the manual for a command
[user@host ~]$ man ls

LS(1)                     User Commands                    LS(1)

NAME
       ls - list directory contents

SYNOPSIS
       ls [OPTION]... [FILE]...

DESCRIPTION
       List information about the FILEs (the current directory
       by default).
...

# Navigation in man pages:
# Space or Page Down - next page
# b or Page Up - previous page
# /pattern - search for pattern
# n - next search result
# q - quit

Remember: Press q to quit the man page and return to the shell.

Man pages are comprehensive documentation available right on the system - no internet required. Every standard command has a man page. man ls shows the manual for the ls command. Man pages follow a standard format: NAME shows the command and brief description. SYNOPSIS shows the command syntax. DESCRIPTION provides detailed explanation. OPTIONS lists all available options. EXAMPLES shows usage examples. SEE ALSO points to related commands. Navigating man pages uses less, so the same keys apply. Space moves forward a page. b moves back. Slash (/) searches - type /recursive to find that word. n finds the next match. q quits. Man pages are organized into sections - section 1 is user commands, section 5 is file formats, section 8 is admin commands. Usually you don't need to specify: man ls works. But man 5 passwd shows the passwd file format, not the passwd command.

Other Help Methods

# Quick help - most commands support --help
[user@host ~]$ ls --help
Usage: ls [OPTION]... [FILE]...
List information about the FILEs...
  -a, --all              do not ignore entries starting with .
  -l                     use a long listing format
...

# Whatis - one-line description
[user@host ~]$ whatis ls
ls (1)               - list directory contents

# Apropos - search for commands by keyword
[user@host ~]$ apropos directory
cd (1)               - change working directory
ls (1)               - list directory contents
mkdir (1)            - make directories
pwd (1)              - print name of current working directory
rmdir (1)            - remove empty directories
...

# Info pages (more detailed than man for some commands)
[user@host ~]$ info ls

Beyond man pages, several other help resources exist. The --help option provides quick, condensed help for most commands. It is shorter than man pages - good for a quick reminder of options. Some commands use -h instead of --help. whatis gives a one-line description of a command. Useful when you see an unfamiliar command and want to know what it does quickly. apropos searches man page descriptions for keywords. When you know what you want to do but not which command does it, apropos helps. apropos directory shows all commands related to directories. info pages are an alternative documentation system. For GNU commands, info pages are often more detailed and tutorial-like than man pages. Navigate with arrow keys, Enter to follow links, q to quit. Between man, --help, and apropos, you can find information about any command without leaving the terminal or searching the web.

Best Practices

Do

Use Tab completion constantly
Check the prompt before typing
Read commands before pressing Enter
Use history and Ctrl+R to recall commands
Read man pages for unfamiliar commands
Start with safe, read-only commands
Log out when finished
Practice regularly to build skills

Do Not

Type commands without understanding them
Ignore error messages
Run commands from the internet blindly
Work as root unnecessarily
Leave sessions logged in unattended
Panic when something goes wrong
Skip reading the prompt (user vs root)
Give up - learning takes practice

Golden rule: If you do not understand what a command does, look it up before running it. This is especially important for commands from the internet.

Let me share some best practices for working at the command line. Use Tab completion constantly - it prevents typos and confirms files exist. Always check the prompt before typing - know whether you are a regular user or root, and which system you are on. Read your command before pressing Enter, especially anything that modifies files. Use history and Ctrl+R - retyping commands wastes time and introduces errors. Read man pages - the documentation is right there, and it answers most questions. Start with safe commands - ls, cat, pwd cannot break anything while you learn. Always log out when done - leaving sessions open is a security risk. Avoid running commands you do not understand. Error messages exist for a reason - read them. Never blindly run commands copied from the internet without understanding them. Work as a regular user, using root only when necessary. Stay calm when things go wrong - panicking makes it worse. And practice regularly - command line skills improve with use.

Key Takeaways

Logging In: Access via console, graphical, SSH, or terminal emulator. Password never displays. Use exit or Ctrl+D to log out.

The Shell: Bash is the command interpreter. It reads commands, executes them, and displays results.

The Prompt: [user@host dir]$ shows username, hostname, directory. $ = user, # = root.

Commands: Structure is command [-options] [arguments]. Use Tab completion, history, and man pages.

Graded Lab

Log in via console and SSH, examine the prompts
Run basic commands: date, whoami, hostname, pwd, id
Practice ls with various options: -l, -a, -la, -lh
Use Tab completion to navigate /etc directory
Search command history with Ctrl+R
Read man pages for date, ls, and cat

Next: Getting Help from Local Documentation

Let me summarize what we have covered. Logging in provides access to the system. You can log in at the console, through a graphical interface, via SSH remotely, or through a terminal emulator. Your password never displays for security. Always log out when done with exit or Ctrl+D. The shell - specifically Bash - is the command-line interpreter. It is the program that reads your commands, figures out what to do, and displays results. The shell is your interface to the power of Linux. The prompt tells you important information: your username, the hostname, your current directory, and whether you are a regular user ($) or root (#). Always check the prompt before typing, especially to confirm you are not accidentally root. Commands follow a consistent structure: the command name, options that modify behavior, and arguments that specify targets. Tab completion helps you type faster and avoid errors. History recalls previous commands. Man pages provide documentation for everything. Your lab exercises give you hands-on practice with these fundamentals. Practice is essential - command line skills build through repetition. These basics form the foundation for everything else in Linux administration.