Linux Syntax Cheat Sheet

Welcome to the Linux Cheat Sheet, a comprehensive guide designed to support your journey through the world of Linux scripting. Inside, you’ll find a thorough command reference section, followed by a Linux code example. The command refernce is complete with descriptions and syntax examples for a wide array of Linux commands and concepts while the code example provides practical demonstrations of how to put these commands to use.

Navigating the Linux command line can sometimes feel like traversing a labyrinth. But with this cheat sheet by your side, you’ll have a reliable map to guide you through. It’s a resource designed as a refresher for commands and concepts, and their usage, as well as a troubleshooting aid. As you grow more comfortable with Linux scripting, this cheat sheet will help transform challenges into opportunities for growth. So, let’s explore Linux scripting together!

Command Reference Section

As we delve into the heart of Linux scripting, our first stop is the command reference section. This comprehensive guide covers the essentials, from file manipulation and system administration to advanced scripting techniques. Each entry is accompanied by a description and an example to illustrate its syntax and usage. This section should serve as a helpful list of commands and provide insight to the Linux command line.

Shell Scripting Concepts

Linux Text Editors

Scripting Languages for Linux

Basic Usage of Git

System Administration

Users and Groups

Process Management

Package Management

System Information

Disk Usage and Management

Files and Filesystem Commands

Filesystem Navigation

File Manipulation

File Permissions

Archiving and Compression

Networking and Security

Networking

Network Utilities

Security

Automation & Virtualization

Automation and Orchestration

Virtualization and Containers

Job Control

Sample Script & Syntax

In the spirit of hands-on learning, we introduce a section dedicated to sample scripts and syntax. Here, you’ll see practical code examples that bring the previously discussed commands and concepts to life. But before we dive into the scripts, we’ll guide you through setting up your environment, so that you can run these examples on your machine.

Preparing Your Environment

1. System Update and Package Installation: Ensure your system is updated and that all necessary packages are installed. Depending on your distribution, use either apt-get (for Debian-based systems) or yum (for Red Hat-based systems).

# Using apt-get
sudo apt-get update
sudo apt-get install -y curl vim tree openssh-client openssh-server git nano mtr iptables ufw

# Using yum
sudo yum update
sudo yum install -y curl vim tree openssh-clients openssh-server git nano mtr iptables-services firewalld

2. User Setup: Ensure you have root privileges for executing commands that require them. If not, prepend sudo to commands as necessary.

3. Directory and Repository Setup: Create and set up the working directory, initialize a Git repository, and prepare log files.

# Create a directory and navigate into it
mkdir -p ~/script_demo/logs && cd ~/script_demo

# Initialize a new Git repository
git init
echo "Git repository initialized."

# Prepare Logs
touch logs/network_log.txt logs/process_log.txt logs/disk_log.txt logs/user_info.txt logs/system_info.txt

# Make any desired initial edits to logs files (to be done manually with nano or another text editor)
# nano logs/[desired_log_file].txt

# Stage and commit logs to the repository
git add logs/*.txt
git commit -m "Initial commit with logs"
echo "Logs committed to the repository."

4. Final Notes Before Running the Script:
   • Be cautious with commands that involve disk partitioning (parted, mkfs), network interface changes (ip addr add), or firewall settings (iptables, ufw). Incorrect usage may lead to connectivity issues or data loss.
   • Secondary SSD assumption: The script assumes an SSD recognized as /dev/sdb. Double-check your device labels (using lsblk or similar commands) to avoid data loss.
   • Script execution: Save the script as setup.sh or another preferred name. Make it executable with chmod +x setup.sh, and execute it with ./setup.sh. If root privileges are required, run it with sudo ./setup.sh

Sample Script

Now that you are able to run scripts on your own, we will present our sample Linux script. It is carefully made to demonstrate practical usage of the Linux commands and concepts outlined in the reference section. Through this example, you’ll learn effective scripting practices and how to combine various commands for optimal results.

#!/bin/bash

# Grab information about the current user and add it to a log
echo "Current user info:" > logs/user_info.txt
whoami >> logs/user_info.txt
echo "User info logged." # Expected action: User information written to log

# Add a test user and set a temporary password
echo "Adding test user..."
sudo useradd testuser
echo testuser:Temp1234 | sudo chpasswd
echo "Test user added and password set to a simple temporary one."
echo -e "\nTest User: testuser" >> logs/user_info.txt # Append test user info to logs/user_info.txt

# Create a new group named 'samplegroup'
sudo groupadd samplegroup

# Add the current user and 'testuser' to 'samplegroup'
sudo usermod -aG samplegroup $USER
sudo usermod -aG samplegroup testuser
echo "Users added to 'samplegroup'."

# Copy a local file to a remote host
scp /path/to/local/file.txt user@remotehost:/path/to/remote/directory/
echo "File has been copied to the remote host."

# Retrieve a file from a remote host to the local machine
scp user@remotehost:/path/to/remote/file.txt /path/to/local/directory/
echo "File has been retrieved from the remote host."

# Create a private file and set permissions
echo "Creating a private file..."
touch sensitive_data.txt
chmod 600 sensitive_data.txt
echo "Sensitive data protection set." # Expected action: File permissions set to owner only

# Downloading, unpacking, and "installing" a package
echo "Downloading and installing a package..."
wget -qO example.tar.gz http://example.com/example.tar.gz
tar -xzf example.tar.gz
echo "Package installed." # Expected output: Download and unpack messages

# Write system Date, Hostname, and Uptime to log
echo "Date: $(date)" > logs/system_info.txt
echo "Hostname: $(hostname)" >> logs/system_info.txt
echo "Uptime: $(uptime -p)" >> logs/system_info.txt

# Capture the most recent system logs
echo "Capturing recent system logs..."
sudo journalctl -n 10 > tmp_logs.txt # Copy recent 10 lines to a temporary log
echo -e "\nRecent System Logs:" >> logs/system_info.txt
cat tmp_logs.txt >> logs/system_info.txt # Transfer info from temporary log to main log
rm tmp_logs.txt # Remove temporary log file
echo "Recent system logs appended to logs/system_info.txt"

# Snapshot of top performance-heavy processes
echo "Grabbing top processes snapshot..."
top -b -n 1 | head -15 > logs/process_log.txt
echo "Top processes snapshot saved to logs/process_log.txt" # Expected action: Top processes info saved

# Multi-step command using awk, grep, sed
echo "Demonstrating awk/grep/sed usage..."
ps aux | grep 'bash' | awk '{print $2}' | sed 's/^/PID: /' > logs/process_log.txt
echo "Bash process PIDs logged." # Expected action: Bash process IDs logged with modification

# Job control example
echo "Starting a background job..."
sleep 60 &  # Starts a sleep command in the background
job_id=$! # Captures the Process ID of the last Job
echo "Background job started with ID: $job_id" # Expected output: Background job ID
kill $job_id # Kill the service
echo "Service (PID: $job_id) has been terminated."

# Start a long-running process (sleep for 100 seconds) in the background with nohup
nohup sleep 100 &> /dev/null &
echo "Long-running process started in the background with nohup."

# Assuming you have background jobs running, list them
jobs
fg %1 # This command will bring job 1 to the foreground, making it interactively controlled.

# Check the status of the SSH service
echo "Checking SSH service status..."
sudo systemctl status ssh | grep "Active:" > logs/system_info.txt
echo "SSH service status written to logs/service_status.txt" #

# Generate an RSA SSH key pair with a comment
ssh-keygen -t rsa -b 4096 -C "[email protected]" -f ~/.ssh/id_rsa -N ""
#Note: (-N "") leaves the passphrase empty for the key, however for security reasons, it's recommended to not use this flag, so that a passphrase can be set.
# Output the public key to the console for easy copying
cat ~/.ssh/id_rsa.pub

# Network restart and log (actual command commented out for safety)
echo "Restarting network interface (simulation)..." >> logs/network_log.txt
# sudo ifdown eth0 && sudo ifup eth0
echo "Network interface restarted." # Expected output: Network restart simulation message

# Check network connection status
echo "Checking network connection status..."
ping -c 4 example.com > /dev/null && echo "Network is up." || echo "Network is down."
# Expected output: "Network is up." or "Network is down."

# Ping a website to check connectivity
ping -c 4 example.com

# Run mtr to trace the route to example.com and show the results
mtr -r -c 1 example.com
# Output:
# HOST: your_local_machine              Loss%   Snt   Last   Avg  Best  Wrst StDev
#   1.|-- 192.168.1.1                    0.0%     1    1.2   1.2   1.2   1.2   0.0
#   2.|-- 10.0.0.1                       0.0%     1    2.4   2.4   2.4   2.4   0.0
#   3.|-- 203.0.113.1                    0.0%     1   10.5  10.5  10.5  10.5   0.0

# Assign a secondary IP address to the secondary network interface (eth1)
sudo ip addr add 192.168.1.100/24 dev eth1
sudo ip link set eth1 up # Bring the interface up
ip addr show eth1 # Check the current IP address
echo "Secondary IP configured and interface brought up."

# List current firewall Rules w/ UFW
echo "Current UFW firewall rules:"
sudo ufw status verbose
# Expected output: Lists all active rules

# Allowing incoming SSH traffic on port 22 w/ UFW
sudo ufw allow 22
echo "Incoming SSH traffic allowed."
# Expected output: Confirmation of rule addition

# Enabling IPtables service to start on boot and saving rules
# For systems using systemd
sudo systemctl enable iptables
sudo iptables-save > /etc/iptables/rules.v4
echo "IPtables service enabled on boot and rules saved."
# Expected output: Confirmation messages

# Blocking incoming traffic from a specific IP address w/ IPtables
sudo iptables -A INPUT -s 192.168.1.100 -j DROP
echo "Incoming traffic from 192.168.1.100 blocked."
# After configuring, don't forget to save:
sudo iptables-save > /etc/iptables/rules.v4
# Expected output: Confirmation of IP block

# Identify a new SSD (assuming /dev/sdb) and create a new partition table
echo "Creating a new GPT partition table on /dev/sdb..."
sudo parted /dev/sdb --script mklabel gpt
echo "Partition table created."

# Optionally, create a single partition covering the entire drive
sudo parted /dev/sdb --script mkpart primary ext4 1MiB 100%
echo "New partition created on /dev/sdb."
# Expected output: Confirmation of partition table and partition creation

# Create mount point and mount the SSD partition
sudo mkdir -p /mnt/ssd
sudo mount /dev/sdb1 /mnt/ssd

# Use rsync to copy logs directory to the SSD
rsync -av ~/script_demo/logs /mnt/ssd/
echo "Logs directory backed up to SSD."

# Use disk management commands to log SSD space info
echo "Logging SSD space information for /dev/sda and /dev/sdb..."
df -h | grep -E '/dev/sda|/dev/sdb' > logs/disk_log.txt
echo "SSD space information for both drives logged."

# List all block devices in a tree-like format
lsblk

# List block devices with additional details like the file system type, label, UUID, and mount point
lsblk -o NAME,FSTYPE,LABEL,UUID,MOUNTPOINT

# Pushing a Commit to Update the Logs
# Assuming logs are updated, add them to the staging area
git add logs/*.txt
echo "Logs added to staging area."

# Commit the update to the repository
git commit -m "Updated Logs"
echo "Log updates committed."

# Push the commit to the remote repository (assuming a remote named 'origin' is set up)
git push origin master
echo "Changes pushed to remote repository."

# (Virtualization) For Docker, a Dockerfile would include steps like:
# FROM ubuntu:latest
# COPY . /app
# RUN apt-get update && apt-get install -y cron
# CMD ["cron", "-f"]

# Schedule this script to run daily using cron (add this line to your crontab manually)
# 0 0 * * * /path/to/your/script.sh

# Final statement
echo "Script execution completed. Logs and other outputs have been generated."

From system administration to network management, this script has covered essential Linux topics and demonstrated the structure and syntax of Linux scripts. As you continue to experiment and learn, remember that this cheat sheet and the concepts it covers are valuable resources at your disposal.

Conclusion

Our journey through the Linux Syntax Cheat Sheet comes to a close, but your adventure in Linux scripting is just beginning. Armed with our command reference and practical coding examples, you’re well-prepared to tackle the challenges and opportunities that lie ahead. As you progress, remember that mastery is gained by continuous learning and experimentation. We wish you all the best as you forge your path in the Linux world, confident in your ability to script effectively and efficiently. Happy scripting, and may you find success in all your coding endeavors!