LEARN

LINUX IN 2 WEEKS

Presented by
DEVOPS DIARIES
Presented by
Avinash Tietler
 TABLE OF CONTENTS

1. Introduction To Linux

2. File Management

3. User Management

4. Networking

5. Process Management

6. Text Editor

7. Shell Scripting

8. Package Management

9. System Monitoring & Performance

10. Security and Permissions

11. Advanced Shell Scripting

12. Linux Services and Daemons

13. Linux in Cloud and DevOps

14. Troubleshooting
 1. INTRODUCTION TO LINUX
What is Linux?
History and Distributions
Linux Architecture Overview

Linux is a free and open-source operating system (OS) based on the

Unix architecture. It was created to provide a reliable, secure, and
efficient operating system for computers, servers, mobile devices, and
embedded systems.

Applications
Shell
Kernel
Hardware

Kernel: At its core, Linux is a kernel, which is the heart of the OS. It
manages system resources and hardware communication.

History of Linux
Unix Inspiration (1969): Unix was developed at Bell Labs as a multi-
user, multitasking operating system.

MINIX (1987): Andrew S. Tanenbaum developed MINIX, a simplified

Unix-like system for educational purposes. This inspired Linus Torvalds
to create Linux.

Linux (1991): Linus Torvalds began writing a new OS kernel as a

personal project. He announced it on August 25, 1991.
The first version (0.01) was released on September 17, 1991.
Torvalds released it under the GNU General Public License (GPL),
combining his kernel with GNU utilities to create a complete OS.
 What is Linux?
History and Distributions
Linux Architecture Overview

Growth and Adoption (1990s-2000s):

Contributions from developers worldwide rapidly improved Linux.
Corporations and communities adopted Linux for servers, desktops,
and embedded systems.

Modern Era:
Linux powers 90% of cloud infrastructure, 100% of the top 500
supercomputers, and the Android operating system.

Popular Linux Distributions

A Linux distribution (distro) is a package that combines the Linux kernel,
GNU tools, libraries, a desktop environment, and other software. There are
hundreds of distros, tailored for specific purposes.
➣ Debian-based:
Debian: Known for stability and extensive software repositories.
Ubuntu: User-friendly, suitable for beginners and professionals.
Linux Mint: Based on Ubuntu, focuses on ease of use and simplicity.
➣ Red Hat-based:
Red Hat Enterprise Linux (RHEL): Enterprise-grade, stable, and secure.
Fedora: Community-driven, cutting-edge technologies.
CentOS: Free RHEL alternative (recently replaced by CentOS Stream).

➣ Arch-based:
Arch Linux: Minimalist and highly customizable, for advanced users.
Manjaro: Beginner-friendly Arch-based distro with pre-configured
settings.
 What is Linux?
History and Distributions
Linux Architecture Overview

➣ Others:
OpenSUSE: Stable and user-friendly, ideal for developers.
Kali Linux: Specialized for penetration testing and ethical hacking.
Alpine Linux: Lightweight and security-focused for containers.

Key Features of Linux

Open Source: Customizable and cost-effective.
Security: Strong built-in security mechanisms.
Multitasking: Efficiently handles multiple processes simultaneously.
Community Support: Active global communities and forums.
Scalability: Suitable for systems of any size, from embedded devices to
data centers.

Layers of Linux Architecture

Hardware Layer
The hardware layer includes the physical components of the system
(CPU, memory, storage, input/output devices).
It interacts with the Linux kernel, which directly communicates with the
hardware through device drivers.

Kernel
The Linux kernel is the core component of the OS, responsible for
managing system resources and hardware communication.
What is Linux?
History and Distributions
Linux Architecture Overview

Key Functions:
1. Process Management: Manages process creation, scheduling, and
termination.
2. Memory Management: Allocates and deallocates memory for
processes and handles virtual memory.
3. Device Drivers: Interfaces with hardware devices like disks,
keyboards, and printers.
4. File System Management: Provides access to and organizes data
in files and directories.
5. Networking: Handles communication between systems over a
network.

Shell
The shell acts as an interface between the user and the kernel.
It interprets user commands and forwards them to the kernel for
execution.

Types of Shells:
1. Bash (Bourne Again Shell): The most common and user-friendly
shell.
2. Zsh (Z Shell): Extended functionality with improved scripting.
3. C Shell (csh): Syntax similar to the C programming language.
4. Korn Shell (ksh): Combines features of the C and Bourne shells.

System Libraries
Libraries provide reusable code for common functionalities like file
handling, memory management, or GUI operations.
GNU C Library (glibc) is an essential library in Linux.
What is Linux?
History and Distributions
Linux Architecture Overview

System Utilities
These are user-level tools and utilities that allow users to perform
tasks like file management, text editing, and process monitoring.
Examples:
ls (list files and directories)
cp (copy files)
ps (process status)
 2. FILE MANAGEMENT
File System Hierarchy in Linux
File Operations (cp, mv, rm, touch, cat)
Understanding File Permissions (chmod, chown)
Hidden Files and Directories

File management in Linux refers to the process of organizing, storing,

retrieving, and manipulating files and directories in the Linux operating
system.

Linux uses a hierarchical directory structure to manage files, starting

from the root directory /.

Linux File Hierarchy

Linux uses a hierarchical file system structure, starting from the root
directory /. All files and directories branch out from this root.

Key Directories:
/ (Root): The top of the file system. All files and directories are under
this.
/bin: Essential user binaries (commands like ls, cp, mv).
/boot: Boot-related files (e.g., the kernel and bootloader
configurations).
/dev: Device files (e.g., sda for disks).
/etc: System configuration files.
/home: Home directories for users (e.g., /home/user).
/lib: Shared libraries and kernel modules.
/opt: Optional software packages.
/tmp: Temporary files.
/usr: User utilities and applications (e.g., /usr/bin, /usr/lib).
/var: Variable files like logs, databases, and cache.
File System Hierarchy in Linux
File Operations (cp, mv, rm, touch, cat)
Understanding File Permissions (chmod, chown)
Hidden Files and Directories

File Operations in Linux

You can manage files in Linux using commands.
Create Files:
touch filename: Creates an empty file.
echo "text" > file: Creates a file with content.
cat > file: Creates a file with text input (press Ctrl+D to save).

Create Directories:
mkdir dirname: Creates a new directory.
mkdir -p parent/child: Creates parent and child directories.

View Files:
cat file: Displays file content.
less file: Displays file content one screen at a time.
head file: Shows the first 10 lines.
tail file: Shows the last 10 lines.

Move/Rename Files:
mv source destination: Moves/renames a file.
Example: mv file1 /tmp/ (move to /tmp) or mv oldname newname.

Copy Files:
cp source destination: Copies a file.
Example: cp file1 /tmp/.

Delete Files and Directories:

rm file: Deletes a file.
rm -r dir: Deletes a directory recursively.
rm -rf dir: Force deletes without prompting.
File System Hierarchy in Linux
File Operations (cp, mv, rm, touch, cat)
Understanding File Permissions (chmod, chown)
Hidden Files and Directories

File Types in Linux:

Regular File (-): Ordinary files (e.g., text files, scripts).
Directory (d): A folder containing files/directories.
Symbolic Link (l): Points to another file or directory.
Device File (b, c): Block/character devices like disks and terminals.
Socket (s): For inter-process communication.
Pipe (p): Used for process communication.

Hidden Files and Directories

Hidden files/directories start with a dot (.). They are not visible by
default.
Examples:
.bashrc: Shell configuration file.
.ssh/: SSH configuration directory.
Commands:
View Hidden Files: Use ls -a or ls -al.
Create Hidden Files: Prefix the name with a dot.
touch .hiddenfile.
Use Cases:
Configuration Files: Hidden files often store settings for users or
applications.
System Files: Some system-related files are hidden to prevent
accidental modification.
File System Hierarchy in Linux
File Operations (cp, mv, rm, touch, cat)
Understanding File Permissions (chmod, chown)
Hidden Files and Directories

File Permissions in Linux

Permissions determine who can read, write, or execute files. Use ls -l to
view permissions.
Permission Types:
Read (r): View file content.
Write (w): Modify file content.
Execute (x): Run the file as a program/script.

Format:
Example: -rwxr-xr--
First character: File type (- for files, d for directories).
Next three characters: Owner permissions (rwx).
Next three characters: Group permissions (r-x).
Last three characters: Others permissions (r — ).

Modify Permissions:
chmod 755 file: Sets permissions using octal values.
7: Read + Write + Execute.
5: Read + Execute.
chmod u+x file: Adds execute permission for the owner (u = user, g =
group, o = others).

Change Ownership:
chown user:group file: Changes owner and group.
Example: chown alice:developers file.txt.
 3. USER MANAGEMENT
Understanding User and Groups
Adding, Modifying, and Deleting Users
Switching Users (su, sudo)
Managing Group Permissions

User management is a fundamental skill for any Linux administrator.

Whether you’re managing access control, securing the system, or
organizing users into groups, Linux provides powerful commands to
handle everything efficiently.

Users and Groups in Linux

🔹 Linux is a multi-user system where each user has a unique UID (User
ID) and belongs to one or more groups.
🔹 Groups help manage permissions efficiently by assigning privileges
to multiple users at once.

Types of users:
✅ Root User: Superuser with unrestricted access.
✅ Regular Users: Have limited permissions.
✅ System Users: Created for running services.

Adding, Modifying, and Deleting Users

Adding a New User
sudo useradd -m username → Creates a user with a home directory
sudo passwd username → Set password for the new user

Modifying a User
sudo usermod -l newname oldname → Rename a user
sudo usermod -aG groupname username → Add user to a group

Deleting a User
sudo userdel username → Delete user but keep files
sudo userdel -r username → Delete user and remove home directory
Understanding User and Groups
Adding, Modifying, and Deleting Users
Switching Users (su, sudo)
Managing Group Permissions

Switching Users: su and sudo

🔹 su - username → Switch to another user (requires password).
🔹 sudo command → Run a command as root (requires sudo access).

Granting sudo access

sudo usermod -aG sudo username
Using sudo without password prompt
sudo visudo
# Add the following line:
username ALL=(ALL) NOPASSWD: ALL

Managing Group Permissions

Create a new group: sudo groupadd groupname
Add user to a group: sudo usermod -aG groupname username
Change a user’s primary group: sudo usermod -g groupname
username
List groups a user belongs to: groups username
Remove a user from a group: sudo deluser username groupname
Delete a group: sudo groupdel groupname

🎯 Key Takeaways:
✅ Use useradd, usermod, userdel for user management.
✅ Switch users with su and sudo.
✅ Manage access with groups and permissions.
✅ Regularly audit user accounts for security.
 4. NETWORKING BASICS
Understanding IP Configuration (ifconfig, ip addr)
Managing Network Interfaces
Checking Connectivity (ping, traceroute)
Basics of SSH and Remote Login

Linux networking is essential for managing communication between

systems and the internet. It involves configuring IP addresses, managing
network interfaces, and ensuring connectivity using tools like ping and
traceroute.

Network interfaces can be controlled using commands like ip and

ifconfig. Secure remote access is achieved through SSH, allowing users
to connect and manage servers remotely.

Understanding these basics helps in troubleshooting and optimizing

network performance in Linux environments.

IP Configuration
IP configuration is essential for network communication. In Linux, you
can configure and view IP addresses, subnet masks, gateways, and DNS
settings.

Key Concepts:
IP Address: A unique identifier for a device on a network (e.g.,
192.168.1.10).
Subnet Mask: Defines the network portion of the IP address (e.g.,
255.255.255.0).
Gateway: The IP address of the router that connects your network
to other networks (e.g., 192.168.1.1).
DNS: Translates domain names (e.g., google.com) to IP addresses.
Understanding IP Configuration (ifconfig, ip addr)
Managing Network Interfaces
Checking Connectivity (ping, traceroute)
Basics of SSH and Remote Login

➲ Commands to View IP Configuration:

ip addr or ifconfig: Displays IP addresses and network interfaces.
ip addr or ifconfig
ip route: Shows the routing table, including the default gateway.
ip route
cat /etc/resolv.conf: Displays DNS servers.
cat /etc/resolv.conf

➲ Managing Network Interfaces:

Network interfaces are the physical or virtual connections (e.g.,
Ethernet, Wi-Fi) that allow your system to communicate over a network.
Commands to Manage Interfaces:
List Network Interfaces:
ip link show
Bring an Interface Up/Down:
sudo ip link set eth0 up # Bring eth0 up
sudo ip link set eth0 down # Bring eth0 down
Assign an IP Address:
sudo ip addr add 192.168.1.10/24 dev eth0
Remove an IP Address:
sudo ip addr del 192.168.1.10/24 dev eth0

➲ Persistent Configuration:
Edit the network configuration file (depends on the Linux distribution):
Debian/Ubuntu: /etc/network/interfaces
Red Hat/CentOS: /etc/sysconfig/network-scripts/ifcfg-eth0
Systemd-based systems: Use netplan (e.g., /etc/netplan/01-
netcfg.yaml).
Understanding IP Configuration (ifconfig, ip addr)
Managing Network Interfaces
Checking Connectivity (ping, traceroute)
Basics of SSH and Remote Login

➲ Checking Connectivity
To troubleshoot network issues, you can use tools like ping and
traceroute.

Ping: Tests connectivity to a host by sending ICMP echo requests.

ping google.com
Press Ctrl+C to stop.

Traceroute: Shows the path packets take to reach a destination and

identifies where delays occur.
traceroute google.com
On some systems, use tracepath instead:
tracepath google.com

Netstat: Displays network connections, routing tables, and interface

statistics.
netstat -tuln # Show listening ports

SS (Socket Statistics): A modern replacement for netstat.

ss -tuln
Understanding IP Configuration (ifconfig, ip addr)
Managing Network Interfaces
Checking Connectivity (ping, traceroute)
Basics of SSH and Remote Login

➲ Basics of SSH and Remote Login

SSH (Secure Shell) is a protocol for securely accessing remote systems
over a network.

SSH Basics:
1. Connect to a Remote Server:
ssh username@remote_host
ssh user@192.168.1.100
2. Specify a Port (default is 22):
ssh -p 2222 user@192.168.1.100
3. Copy Files with SCP:
scp file.txt user@192.168.1.100:/path/to/destination
4. Generate SSH Keys (for passwordless login):
ssh-keygen -t rsa -b 4096
5. Copy the public key to the remote server:
ssh-copy-id user@192.168.1.100

SSH Configuration File:

Edit ~/.ssh/config to simplify SSH connections:
Host myserver
HostName 192.168.1.100
User user
Port 22
Now you can connect using:
ssh myserver
 5. PROCESS MANAGEMENT
Viewing Processes (ps, top, htop)
Managing Processes (kill, pkill, nice, renice)
Background and Foreground Processes (&, fg, bg)

Process management in Linux is the mechanism by which the operating

system handles running programs (processes), allowing users to
monitor, control, and optimize system performance. Each process has a
unique Process ID (PID) and can have different states like running,
sleeping, or terminated.

Viewing Processes in Linux

To effectively manage processes, you need to view them first. Linux
provides several commands for this:

ps (Process Status)
The ps command displays a snapshot of currently running
processes.
It does not update dynamically like top or htop.
ps aux # Shows all running processes with details
ps -ef # Alternative format for displaying all processes
ps -u <username> # Shows processes for a specific user
ps -p <PID> # Displays information about a specific process

top (Dynamic Process Viewer)

The top command provides a real-time view of running processes.
Displays CPU and memory usage dynamically.
top # Starts the top interface
Useful shortcuts inside top:
k → Kill a process (asks for PID)
r → Renice (change priority)
q → Quit top
Viewing Processes (ps, top, htop)
Managing Processes (kill, pkill, nice, renice)
Background and Foreground Processes (&, fg, bg)

htop (Enhanced Process Viewer)

htop is an interactive version of top with better visualization.
It allows you to scroll and kill processes easily.
sudo apt install htop # Debian/Ubuntu
sudo yum install htop # RHEL/CentOS
htop # Launch htop
Inside htop, you can use arrow keys to navigate, and F9 to kill a process.

Managing Processes in Linux

Once you identify a process, you may need to control it using various
commands.

kill (Terminate a Process by PID)

The kill command sends signals to processes to stop them.
kill -9 <PID> # Forcefully kills a process
kill -15 <PID> # Gracefully stops a process (default)
kill -SIGSTOP <PID> # Stops (pauses) a process
kill -SIGCONT <PID> # Resumes a stopped process

pkill (Kill by Process Name)

pkill kills a process using its name instead of PID.
pkill firefox # Kills all instances of Firefox
pkill -9 chrome # Force kills all Chrome processes

nice (Start a Process with Priority)

Linux assigns priorities to processes (Range: -20 to 19, where -20 is
highest and 19 is lowest).
nice -n 10 myscript.sh # Starts myscript.sh with lower priority
Viewing Processes (ps, top, htop)
Managing Processes (kill, pkill, nice, renice)
Background and Foreground Processes (&, fg, bg)

renice (Change Priority of Running Process)

Modify priority of a running process.
renice -5 -p <PID> # Increase priority of process
renice 10 -u <username> # Change priority of all processes by a user

Background & Foreground Processes

Processes can be run in foreground (blocking terminal) or background.

1. Running a Process in Background (use &)

firefox & # Runs Firefox in background
2. Bringing a Background Process to Foreground (use fg)
fg %1 # Brings process with job ID 1 to foreground
3. Listing Background Jobs (jobs)
jobs # Lists all background processes with job numbers
4. Resuming a Stopped Process in Background (bg)
bg %1 # Resumes job 1 in background

Summary
Viewing Processes: Use ps, top, or htop to monitor processes.
Managing Processes: Use kill, pkill, nice, and renice to control
processes.
Background/Foreground Processes: Use &, fg, bg, and Ctrl+Z to
manage process execution states.
 6. LINUX TEXT EDITORS
Basics of vi/vim
nano and other common editors
Editing, saving, and quitting files

Whether you’re a developer, system administrator, or just someone who

loves tinkering with Linux, text editors are an indispensable part of your
toolkit. From lightweight editors for quick edits to powerful IDEs for
complex coding, Linux has something for everyone. In this article, we’ll
explore some of the most popular Linux text editors and help you
choose the right one for your workflow.

Why Text Editors Matter in Linux

Used for
Editing configuration files (e.g., /etc/fstab, ~/.bashrc).
Writing scripts (Bash, Python, etc.).
Coding and software development.
Lightweight alternatives to heavy IDEs.

Categories of Linux Text Editors

We have divided text editors into categories to help readers understand
their use cases:
Terminal-Based Text Editors: Lightweight, fast, and ideal for
remote servers.
Graphical Text Editors: User-friendly and feature-rich for desktop
environments.
Integrated Development Environments (IDEs): Advanced tools
for developers.
 Basics of vi/vim
nano and other common editors
Editing, saving, and quitting files

Popular Linux Text Editors

Provide an overview of the most widely used text editors, highlighting
their strengths and weaknesses.
Terminal-Based Editors:

Vi/Vim
Vi is a classic, screen-oriented text editor originally created for Unix.
Vim (Vi Improved) is an enhanced version of Vi, with additional
features like syntax highlighting, plugins, and better user interface
options.
Vim is pre-installed on most Linux distributions and is widely used
for editing configuration files, writing code, and scripting.

Nano
Simple and beginner-friendly.
Easy-to-use interface with on-screen shortcuts.
Ideal for quick edits and beginners.

Emacs
Highly customizable and extensible.
More than just a text editor — it’s an ecosystem for coding, email,
and more.
Requires time to learn but offers unmatched flexibility.
Basics of vi/vim
nano and other common editors
Editing, saving, and quitting files

How to Choose the Right Text Editor

Provide tips for readers to decide which text editor suits their needs:
For Beginners: Start with Nano or Gedit.
For System Administrators: Learn Vi/Vim for remote server
management.
For Developers: Use VS Code, Sublime Text, or an IDE like IntelliJ.
For Customization Enthusiasts: Explore Emacs or Vim with plugins.

Tips for Getting Started

Learn the Basics: Start with simple editors like Nano before moving
to advanced ones like Vim.
Customize Your Editor: Most editors support plugins, themes, and
shortcuts to enhance productivity.
Practice Regularly: The more you use a text editor, the more
efficient you’ll become.
 7. SHELL SCRIPTING
What is Shell Scripting?
Writing Your First Script
Variables, Loops, and Conditionals
Simple Automation with Shell Scripts

Shell scripting is one of the most powerful tools in a Linux user’s arsenal.
Whether you’re a system administrator, developer, or just a curious
Linux enthusiast, learning shell scripting can save you time and effort by
automating repetitive tasks.

In this post, we’ll cover the basics of shell scripting, from writing your
first script to using variables, loops, and conditionals. Let’s dive in!

What is Shell Scripting?

A shell script is a text file containing a series of commands that are
executed by the shell (e.g., Bash, the default shell in most Linux
distributions). Shell scripts are used to automate tasks, manage system
operations, and perform complex workflows with just a few lines of
code.

Why use shell scripting?

Automate repetitive tasks (e.g., backups, file management).
Combine multiple commands into a single script.
Schedule tasks using cron jobs.
Simplify complex workflows.
 What is Shell Scripting?
Writing Your First Script
Variables, Loops, and Conditionals
Simple Automation with Shell Scripts

Writing Your First Script

Let’s start by creating a simple “Hello, World!” script.

Open a terminal and create a new file: nano hello.sh

Add the following lines to the file:
#!/bin/bash
echo “Hello, World!”

#!/bin/bash is called the shebang. It tells the system to use the Bash
shell to execute the script.
echo is a command that prints text to the terminal.

Save the file and exit the editor (in Nano, press Ctrl+O to save and
Ctrl+X to exit).
Make the script executable: chmod +x hello.sh
Run the script: ./hello.sh
You should see the output: Hello, World!
What is Shell Scripting?
Writing Your First Script
Variables, Loops, and Conditionals
Simple Automation with Shell Scripts

Variables, Loops, and Conditionals

Now that you’ve written a simple script, let’s explore some fundamental
concepts.

Variables
Variables are used to store data. In shell scripting, you can create a
variable and use it later in your script.
#!/bin/bash
name=”Avinash”
echo “Hello, $name!”
Output: Hello, $name!
Variables are assigned using = (no spaces around the =).
To access a variable’s value, use $ followed by the variable name.

Loops
Loops allow you to repeat a set of commands. The most common loop in
shell scripting is the for loop.
#!/bin/bash
for i in 1 2 3 4
do
echo “Number: $i”
done

Conditionals
Conditionals allow you to execute commands based on certain conditions.
The most common conditional is the if statement.
#!/bin/bash
age=18
if [ $age -ge 18 ]; then
What is Shell Scripting?
Writing Your First Script
Variables, Loops, and Conditionals
Simple Automation with Shell Scripts

echo “You can Vote.”

else
echo “You are a minor.”
fi
Output: You can Vote.
-ge stands for "greater than or equal to."
Always use spaces around the conditions inside [ ].

Simple Automation with Shell Scripts

Shell scripts are perfect for automating repetitive tasks. Here’s an
example of a script that backs up a directory:
#!/bin/bash
# Backup script
backup_dir=”/home/user/documents”
backup_dest=”/home/user/backup”

# Create a timestamp
timestamp=$(date +”%Y%m%d_%H%M%S”)

# Create backup
tar -czf $backup_dest/backup_$timestamp.tar.gz $backup_dir
echo “Backup completed: backup_$timestamp.tar.gz”

What this script does:

1. Defines the source (backup_dir) and destination (backup_dest)
directories.
2. Creates a timestamp for the backup file.
3. Uses tar to compress and archive the directory.
4. Prints a confirmation message.
 8. PACKAGE MANAGEMENT
Installing and Managing Software (apt, yum, dnf, zypper)
Working with Snap and Flatpak
Updating and Removing Software

Package management is a core feature of Linux distributions that

simplifies the process of installing, updating, configuring, and removing
software. It ensures that software is installed in a consistent manner,
resolves dependencies, and maintains the system’s stability.

Linux distributions use package managers to handle software packages,

which are archives containing the software, metadata, and instructions
for installation.

Installing and Managing Software

In Linux, software is distributed in the form of packages. These
packages are managed by package managers, which are tools that
automate the process of installing, updating, and removing software.
Each Linux distribution typically has its own package manager and
package format. Some of the most common package managers include:

APT (Advanced Package Tool) — Used by Debian-based distributions

like Ubuntu.
YUM/DNF — Used by Red Hat-based distributions like Fedora and
CentOS.
Pacman — Used by Arch Linux.
Zypper — Used by openSUSE.

Installing Software
To install software using a package manager, you typically use a
command like:
APT (Debian/Ubuntu): sudo apt install package_name
DNF (Fedora): sudo dnf install package_name
Pacman (Arch): sudo pacman -S package_name
 Installing and Managing Software (apt, yum, dnf, zypper)
Working with Snap and Flatpak
Updating and Removing Software

The package manager downloads the software from a repository (a server

hosting software packages) and installs it along with any required
dependencies.

Searching for Software

You can search for available packages using:
APT: apt search keyword
DNF: dnf search keyword
Pacman: pacman -Ss keyword

Working with Snap and Flatpak

Snap and Flatpak are universal package formats that work across multiple
Linux distributions. They bundle software along with its dependencies,
making it easier to distribute and run applications on any Linux system.

Snap
Developed by Canonical (the company behind Ubuntu).
Packages are called snaps.
Managed by the snapd service.
Installing Snap: sudo apt install snapd
Installing Software with Snap: sudo snap install package_name
Updating Snap Packages: sudo snap refresh package_name
Removing Snap Packages: sudo snap remove package_name

Flatpak
A community-driven universal package format.
Packages are hosted in repositories called remotes.
Managed by the flatpak command.
Installing Flatpak: sudo apt install flatpak
 Installing and Managing Software (apt, yum, dnf, zypper)
Working with Snap and Flatpak
Updating and Removing Software

Installing Software with Flatpak: flatpak install flathub package_name

Updating Flatpak Packages: flatpak update
Removing Flatpak Packages: flatpak uninstall package_name

Updating and Removing Software

Updating Software
Keeping your system up to date is crucial for security and performance.
Package managers allow you to update all installed software with a single
command.
APT: sudo apt update # Refreshes the package list
sudo apt upgrade # Upgrades installed packages
sudo apt full-upgrade # Upgrades and handles dependencies

Removing Software
To remove software, use the appropriate command for your package
manager.
APT: sudo apt remove package_name # Removes the package
sudo apt purge package_name # Removes the package and its
configuration files

Summary
Package Managers are essential tools for installing, updating, and
removing software in Linux.
Snap and Flatpak provide universal packaging solutions, making it easier
to distribute and run software across different Linux distributions.
Regular updates ensure your system is secure and up to date.
Properly removing software and cleaning up unused packages helps
maintain system performance.
 9. SYSTEM PERFORMANCE AND TUNING

Installing and Managing Software (apt, yum, dnf, zypper)

Working with Snap and Flatpak
Updating and Removing Software

System monitoring and performance tuning in Linux are critical tasks for
ensuring that a system runs efficiently and reliably. These tasks involve
tracking system resources, identifying bottlenecks, and optimizing
performance. Below is a detailed explanation of the key components,
including disk usage and monitoring, memory and CPU monitoring, and
analyzing system logs.

Disk Usage and Monitoring

Disk usage and monitoring tools help track how disk space is being utilized
and identify potential performance issues related to disk I/O.
Tools:
df (Disk Free):
Displays the amount of disk space used and available on mounted
filesystems.
Example: df -h (human-readable format).
Output includes filesystem, size, used space, available space, and mount
point.
du (Disk Usage):
Estimates file and directory space usage.
Example: du -sh /path/to/directory (summary in human-readable format).
Useful for identifying large files or directories consuming disk space.
iostat (Input/Output Statistics):
Part of the sysstat package, it provides detailed I/O statistics for devices and
partitions.
Example: iostat -x 1 (extended statistics, updated every second).
Metrics include read/write operations per second (r/s, w/s), throughput
(kB_read/s, kB_wrtn/s), and utilization (%util).
 Disk Usage and Monitoring (df, du, iostat)
Memory and CPU Monitoring (free, vmstat, sar)
Analyzing System Logs (journalctl, dmesg)

Memory and CPU Monitoring

Monitoring memory and CPU usage helps identify resource bottlenecks and
optimize system performance.
Tools:
free (Memory Usage):
Displays the total, used, and free memory (RAM and swap).
Example: free -h (human-readable format).
Key metrics: total, used, free, shared, buff/cache, and available memory.

vmstat (Virtual Memory Statistics):

Provides an overview of system performance, including CPU, memory, and
I/O.
Example: vmstat 1 (updates every second).
Key metrics: processes (r = running, b = blocked), memory (swpd, free, buff,
cache), swap (si, so), I/O (bi, bo), and CPU (us, sy, id, wa).

sar (System Activity Reporter):

Part of the sysstat package, it collects and reports system activity over time.
Example: sar -u 1 (CPU usage every second), sar -r 1 (memory usage every
second).
Useful for historical performance analysis.
 Disk Usage and Monitoring (df, du, iostat)
Memory and CPU Monitoring (free, vmstat, sar)
Analyzing System Logs (journalctl, dmesg)

Analyzing System Logs

System logs provide insights into system events, errors, and performance
issues. Analyzing logs is essential for troubleshooting and maintaining
system health.

Tools:
journalctl (Systemd Journal):
Queries and displays logs managed by the systemd journal.
Example: journalctl -xe (view recent logs with extended details).
Filters: journalctl -u service_name (logs for a specific service), journalctl --
since "2023-10-01" --until "2023-10-02" (logs within a time range).

dmesg (Kernel Ring Buffer):

Displays kernel-related messages, including hardware and driver events.
Useful for diagnosing hardware and boot-related issues.

Performance Tuning
Performance tuning involves optimizing system parameters to improve
efficiency. Common areas for tuning include:
Disk I/O: Use tools like ionice to adjust I/O priority.
Optimize filesystem mount options (e.g., noatime for ext4).

Memory: Adjust swappiness (vm.swappiness) to control swap usage.

Monitor and clear caches if necessary (echo 3 >
/proc/sys/vm/drop_caches).

CPU: Use nice and renice to adjust process priorities.

Optimize CPU frequency scaling (e.g., using cpufreq).
 10. SECURITY AND PERMISSIONS

Setting Advanced Permissions (ACLs, SUID, SGID)

Using Firewalls (ufw, iptables)
Basics of SELinux and AppArmor
Security and permissions in Linux are fundamental aspects of system
administration that ensure the confidentiality, integrity, and availability
of system resources.

Linux provides a robust set of tools and mechanisms to manage

access control, enforce security policies, and protect against
unauthorized access.

Advanced Permissions
Linux uses a combination of traditional file permissions and advanced
mechanisms like ACLs, SUID, and SGID to provide fine-grained access
control.

ACLs (Access Control Lists):

ACLs extend the standard file permissions (read, write, execute) to
allow more specific access control for users and groups.

Commands:
setfacl: Sets ACLs for files or directories.
setfacl -m u:username:rwx file.txt (grants read, write, and execute
permissions to a specific user).
getfacl: Displays ACLs for a file or directory.
getfacl file.txt.

Use Case: Useful when you need to grant permissions to multiple users
or groups beyond the standard owner/group/others.
 Setting Advanced Permissions (ACLs, SUID, SGID)
Using Firewalls (ufw, iptables)
Basics of SELinux and AppArmor

SUID (Set User ID):

What it is: When the SUID bit is set on an executable file, the file runs
with the permissions of the file owner, not the user executing it.

How to Set:
chmod u+s file (sets SUID bit).
Example: chmod u+s /usr/bin/passwd (allows users to change their
passwords by running the passwd command with root privileges).
Security Consideration: Use SUID sparingly, as it can introduce security
risks if misconfigured.

SGID (Set Group ID):

What it is: When the SGID bit is set on a directory, files created within
the directory inherit the group ownership of the directory, not the
user's primary group.

How to Set:
chmod g+s directory (sets SGID bit).
Example: chmod g+s /shared_directory (ensures all files in
/shared_directory belong to the same group).
Use Case: Useful for collaborative environments where multiple users
need to share files.
 Setting Advanced Permissions (ACLs, SUID, SGID)
Using Firewalls (ufw, iptables)
Basics of SELinux and AppArmor

Using Firewalls
Firewalls are essential for controlling incoming and outgoing network
traffic. Linux provides tools like ufw and iptables to configure firewall
rules.

ufw (Uncomplicated Firewall):

What it is: A user-friendly interface for managing iptables.
Commands:
Enable/disable: sudo ufw enable, sudo ufw disable.
Allow/deny traffic: sudo ufw allow 22/tcp (allow SSH), sudo ufw deny
80/tcp (block HTTP).
Check status: sudo ufw status.
Use Case: Ideal for beginners or simple firewall configurations.

iptables:
What it is: A powerful command-line tool for configuring firewall rules.
Commands:
Allow traffic: sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
(allow SSH).
Block traffic: sudo iptables -A INPUT -p tcp --dport 80 -j DROP
(block HTTP).
List rules: sudo iptables -L.
Use Case: Suitable for advanced users who need granular control over
network traffic.
 Setting Advanced Permissions (ACLs, SUID, SGID)
Using Firewalls (ufw, iptables)
Basics of SELinux and AppArmor

Basics of SELinux and AppArmor

SELinux and AppArmor are Linux security modules that provide
mandatory access control (MAC) to enforce security policies.

SELinux (Security-Enhanced Linux):

A security module developed by the NSA that enforces access control
based on policies.
Key Concepts:
Modes: Enforcing (policies are enforced), Permissive (policies are
logged but not enforced), Disabled.
Contexts: Files, processes, and users are assigned security
contexts (e.g., user_u:role_r:type_t).

Commands:
Check status: sestatus.
Change mode: sudo setenforce Enforcing or sudo setenforce
Permissive.
View context: ls -Z (files), ps -Z (processes).
Use Case: Commonly used in enterprise environments for enhanced
security.
 Setting Advanced Permissions (ACLs, SUID, SGID)
Using Firewalls (ufw, iptables)
Basics of SELinux and AppArmor

AppArmor:
A security module that confines programs to a limited set of resources
using profiles.
Key Concepts:
Profiles: Each application has a profile defining its allowed actions
and resources.
Modes: Enforce (restricts access), Complain (logs violations but
does not restrict).
Commands:
Check status: sudo apparmor_status.
Load/unload profiles: sudo apparmor_parser -r
/etc/apparmor.d/profile_name.
Use Case: Easier to configure than SELinux and often used in Ubuntu
and other distributions.

Summary
Advanced Permissions: Use ACLs, SUID, and SGID for fine-grained
access control.
Firewalls: Use ufw for simplicity or iptables for advanced
configurations.
SELinux and AppArmor: Implement mandatory access control to
enforce security policies.
 11. ADVANCED SHELL SCRIPTING

Writing Complex Scripts

Using Functions and Arrays
Scheduling with Cron Jobs

Learning advanced shell scripting in Linux is a great way to automate

tasks, manage systems, and improve your overall efficiency. Below is a
structured guide to help you master advanced shell scripting:

Before diving into advanced topics, ensure you have a solid

understanding of:
Basic Linux commands (e.g., ls, cd, grep, awk, sed, find, etc.).
Basic shell scripting concepts (e.g., variables, loops, conditionals,
functions, and file handling).

Here are the key areas to focus on for advanced shell scripting:
a. Advanced Variable Manipulation
Parameter Expansion: Learn ${variable#pattern},
${variable%pattern}, ${variable//pattern/replacement}, etc.
Arrays: Work with indexed and associative arrays.
Environment Variables: Understand how to set and use them
effectively.
b. Functions
Writing reusable functions.
Passing arguments to functions.
Returning values from functions.
Local vs global variables.
c. Input/Output Redirection
Advanced redirection (>, >>, 2>, &>, <<, etc.).
Using exec to redirect input/output for the entire script.
Process substitution (<(command) and >(command)).
 Writing Complex Scripts
Using Functions and Arrays
Scheduling with Cron Jobs

d. Regular Expressions
Using grep, sed, and awk with regex.
Pattern matching in shell scripts.
e. Advanced Control Structures
Nested loops and conditionals.
Using case statements for complex decision-making.
select for creating menus.
f. Error Handling
Checking exit codes ($?).
Using trap to handle signals and errors.
Logging and debugging techniques.
g. Process Management
Running commands in the background (&).
Using wait to synchronize processes.
Job control (jobs, fg, bg).
Killing processes (kill, pkill).
h. Text Processing
Advanced usage of awk and sed.
Parsing CSV, JSON, and XML files (using tools like jq for
JSON).
Working with multi-line text.
i. File and Directory Manipulation
Recursive directory traversal.
Handling file permissions and ownership.
Using find with -exec or xargs.
 Writing Complex Scripts
Using Functions and Arrays
Scheduling with Cron Jobs
j. Networking
Writing scripts to interact with network utilities (curl, wget, nc,
ssh, etc.).
Automating network tasks (e.g., checking connectivity,
downloading files).
k. Script Optimization
Writing efficient scripts.
Avoiding common pitfalls (e.g, excessive use of external
commands).
Using shell built-ins whenever possible.
l. Security
Writing secure scripts (e.g., avoiding code injection).
Handling sensitive data (e.g., passwords, API keys).
Using set -e, set -u, and set -o pipefail for safer scripts.

Writing Complex Scripts

Complex scripts often involve multiple tasks, error handling, and
logical flow. Here’s an example of a complex script that performs
file backups, checks for errors, and logs the results.

Key Points:
Use set -e to exit the script immediately if any command fails.
Use trap to handle unexpected errors or interruptions.
Log all actions for debugging and auditing purposes.
 Writing Complex Scripts
Using Functions and Arrays
Scheduling with Cron Jobs

Using Functions and Arrays

Functions and arrays make scripts modular and reusable.

Key Points:
Use local to limit the scope of variables within functions.
Pass arrays to functions using "${array[@]}".
Functions can return values using echo or by modifying global
variables.

Scheduling with Cron Jobs in Linux

Cron Jobs in Linux allow users to schedule repetitive tasks at
specified intervals. The cron daemon (crond) runs in the
background, executing scheduled commands automatically. It is
widely used for automating system maintenance, backups, script
execution, and more.

Understanding Cron Syntax

A cron job follows this format:
* * * * command_to_execute
│││││
│ │ │ │ └── Day of the week (0–6) [Sunday=0]
│ │ │ └──── Month (1–12)
│ │ └────── Day of the month (1–31)
│ └──────── Hour (0–23)
└────────── Minute (0–59)
Run a script at 2:30 AM every day: 30 2 * * * /path/to/script.sh
 12. SERVICES AND DAEMONS

Starting, Stopping, and Managing Services (systemctl, service)

Configuring Startup Services
Understanding Init Systems (SysVinit vs. systemd)

Learning about Linux services and daemons is a great way to

deepen your understanding of how Linux systems operate.

In this chapter, get started with Linux services, including starting,

stopping, and managing them, as well as configuring startup
services and understanding init systems like SysVinit and systemd.

Services: A service is a program or process that runs in the

background to perform specific tasks (e.g., web servers,
databases, or network services).
Daemons: A daemon is a type of service that runs in the
background, often started during system boot, and waits for
requests to perform its task.

Starting, Stopping, and Managing Services

Linux provides tools to manage services, such as systemctl and
service.

Using systemctl (for systemd systems)

systemctl is the primary tool for managing services in systems
using systemd (most modern Linux distributions).

Using service (for SysVinit systems)

The service command is used in older systems that use the
SysVinit init system.
 Starting, Stopping, and Managing Services (systemctl, service)
Configuring Startup Services
Understanding Init Systems (SysVinit vs. systemd)
Systemctl:
Status of a service: sudo systemctl status <service-name>
Start a service: sudo systemctl start <service-name>
Stop a service: sudo systemctl stop <service-name>
Restart a service: sudo systemctl restart <service-name>
Enable a service to start at boot: sudo systemctl enable
<service-name>
Disable a service from starting at boot: sudo systemctl disable
<service-name>
Reload a service’s configuration: sudo systemctl reload
<service-name>

Service:
Start a service: sudo service <service-name> start
Stop a service: sudo service <service-name> stop
Restart a service: sudo service <service-name> restart
Check the status of a service: sudo service <service-name>
status

Configuring Startup Services

Configuring which services start at boot is an important part of
managing a Linux system.

The init system is the first process that starts when a Linux system
boots. It is responsible for starting and managing other services
and daemons.
 Starting, Stopping, and Managing Services (systemctl, service)
Configuring Startup Services
Understanding Init Systems (SysVinit vs. systemd)

SysVinit
The traditional init system used in older Linux distributions.
Uses scripts located in /etc/init.d/ to manage services.
Services are started sequentially, which can lead to slower
boot times.
Managed using commands like service and chkconfig.
systemd
The modern init system used in most Linux distributions today
(e.g., Ubuntu, Fedora, CentOS 7+).
Uses units (.service files) located in /etc/systemd/system/ or
/lib/systemd/system/.
Starts services in parallel, leading to faster boot times.
Managed using the systemctl command.
 13. LINUX IN CLOUD AND DEVOPS

Linux in Cloud Computing

Linux in DevOps
DevOps Tools That Rely on Linux

Linux in Cloud Computing

Major Cloud Providers Use Linux: AWS, Azure, Google Cloud, and
other cloud providers run most of their services on Linux-based
infrastructure.
Lightweight and Efficient: Linux is known for its low resource
consumption, making it ideal for virtual machines (VMs),
containers, and cloud-based applications.
Security and Stability: Linux has built-in security mechanisms like
SELinux, AppArmor, and iptables, making it highly secure for
cloud environments.
Open Source and Cost-Effective: Many cloud services run on
open-source Linux distributions, reducing licensing costs
compared to proprietary OSs like Windows.

Cloud computing relies on Linux because of its performance,

scalability, and flexibility.

Cloud Services Built on Linux

AWS EC2, Azure VM, GCP Compute Engine: These services offer
Linux-based VMs.
AWS Lambda, Azure Functions: Support Linux-based serverless
functions.
Kubernetes (Managed Kubernetes in Cloud): Services like
Amazon EKS, Azure AKS, and Google GKE run on Linux nodes.
Cloud Storage & Databases: Many cloud databases (MySQL,
PostgreSQL, MongoDB) run on Linux.
 Linux in Cloud Computing
Linux in DevOps
DevOps Tools That Rely on Linux

Linux in DevOps
Most DevOps Tools Run on Linux: Tools like Docker, Kubernetes,
Jenkins, Terraform, Ansible, and Prometheus are designed for
Linux environments.
Scripting and Automation: Shell scripting (Bash, Zsh) and
automation tools work seamlessly in Linux, enabling DevOps
engineers to automate tasks efficiently.
Containerization & Microservices: Docker containers, Kubernetes
clusters, and CI/CD pipelines are primarily deployed on Linux-
based servers.
Infrastructure as Code (IaC): Terraform and Ansible use Linux-
friendly configurations to manage cloud infrastructure efficiently.

DevOps Tools That Rely on Linux

Configuration Management: Ansible, Puppet, Chef (all work best on
Linux)
Containerization & Orchestration: Docker, Kubernetes (designed
for Linux)
CI/CD Pipelines: Jenkins, GitLab CI/CD (most run on Linux servers)
Monitoring & Logging: Prometheus, Grafana, ELK Stack
(ElasticSearch, Logstash, Kibana)
Infrastructure as Code (IaC): Terraform, CloudFormation (primarily
Linux-based)
Version Control: Git (CLI works best in Linux)
 Linux in Cloud Computing
Linux in DevOps
DevOps Tools That Rely on Linux

Cloud Use Cases

1. Deploying Applications on Cloud VMs: Running web apps, APIs,
and microservices on Linux servers.
2. Serverless Computing: Running functions and serverless apps
using Linux environments.
3. Containerized Applications: Deploying Docker containers and
Kubernetes clusters.
4. Database Hosting: Running MySQL, PostgreSQL, and NoSQL
databases on Linux.
5. Logging & Monitoring: Setting up Prometheus, Grafana, and
centralized logging.

DevOps Use Cases

1. Automating Deployments: Using Ansible to configure cloud
instances.
2. CI/CD Pipelines: Running Jenkins pipelines on Linux servers.
3. Infrastructure as Code (IaC): Writing Terraform scripts for
provisioning cloud infrastructure.
4. Kubernetes Cluster Management: Managing containerized
workloads using kubectl commands.
5. Security & Compliance: Configuring firewalls, securing SSH
access, and monitoring system logs.
 14. TROUBLESHOOTING
Debugging Common Linux Issues
Working with Network Tools

Mastering Linux troubleshooting is a valuable skill that can significantly

enhance your ability to manage and maintain Linux systems. Below is a
comprehensive guide to help you get started and become proficient in
Linux troubleshooting.

Linux Boot Process

BIOS/UEFI: The system firmware that initializes hardware and starts
the boot loader.
Boot Loader (GRUB): Loads the Linux kernel into memory.
Kernel Initialization: The kernel initializes hardware and mounts the
root filesystem.
Init System (systemd, SysVinit): Starts essential services and brings
the system to a usable state.

Troubleshooting Tips:
GRUB Issues: Use a live CD/USB to chroot into the system and
reinstall GRUB.
Kernel Panics: Check kernel logs (dmesg) and ensure hardware
compatibility.
Init System Failures: Use journalctl (for systemd) or check
/var/log/messages for errors.

Master the Command Line

Basic Commands: ls, cd, pwd, cp, mv, rm, mkdir, rmdir, cat, more,
less, tail, head, grep, find, awk, sed.
System Monitoring: top, htop, ps, free, df, du, vmstat, iostat.
Networking: ifconfig, ip, netstat, ss, ping, traceroute, nslookup, dig.
Package Management: apt, yum, dnf, rpm, dpkg.
 Debugging Common Linux Issues
Working with Network Tools

Troubleshooting Tips:
Resource Usage: Use top or htop to identify resource-hogging
processes.
Network Issues: Use ping and traceroute to diagnose connectivity
problems.
Package Issues: Use dpkg -l or rpm -qa to verify installed packages.

Understand Log Files

System Logs: /var/log/syslog, /var/log/messages.
Authentication Logs: /var/log/auth.log, /var/log/secure.
Kernel Logs: dmesg, /var/log/kern.log.
Application Logs:
/var/log/apache2/error.log,/var/log/mysql/error.log.

Troubleshooting Tips:
Log Rotation: Use logrotate to manage log file sizes.
Real-time Monitoring: Use tail -f /var/log/syslog to monitor logs in
real-time.
Log Analysis: Use grep, awk, and sed to filter and analyze logs.

Filesystem and Disk Management

Filesystem Types: ext4, XFS, Btrfs, ZFS.
Disk Management: fdisk, parted, lsblk, blkid.
Mounting: mount, umount, /etc/fstab.
Filesystem Checks: fsck, e2fsck.
 Debugging Common Linux Issues
Working with Network Tools

Troubleshooting Tips:
Disk Space: Use df -h to check disk usage and du -sh * to find large
files.
Filesystem Corruption: Use fsck to check and repair filesystems.
Mount Issues: Check /etc/fstab for errors and use dmesg to identify
mount failures.

Networking and Connectivity

Network Configuration:
/etc/network/interfaces,/etc/sysconfig/network-scripts/.
DNS: /etc/resolv.conf, /etc/hosts.
Firewall: iptables, ufw, firewalld.
Network Services: sshd, httpd, nginx, mysql.

Troubleshooting Tips:
Connectivity: Use ping and traceroute to diagnose network issues.
DNS Issues: Check /etc/resolv.conf and use nslookup or dig to test
DNS resolution.
Firewall Rules: Use iptables -L or ufw status to verify firewall rules.

Process and Service Management

Process Management: ps, top, htop, kill, pkill, pgrep.
Service Management: systemctl, service, chkconfig.
 Debugging Common Linux Issues
Working with Network Tools

Troubleshooting Tips:
Service Failures: Use systemctl status <service> to check service
status and logs.
Process Issues: Use ps aux | grep <process> to find and manage
processes.
Resource Limits: Use ulimit to check and set resource limits.

Security and Permissions

User Management: useradd, usermod, userdel, passwd.
Permissions: chmod, chown, chgrp, umask.
SELinux/AppArmor: sestatus, getenforce, setenforce.

Troubleshooting Tips:
Permission Issues: Use ls -l to check file permissions and ownership.
SELinux/AppArmor: Use audit2allow to analyze and fix SELinux denials.
User Access: Check /etc/passwd, /etc/shadow, and /etc/group for
user and group information.

Backup and Recovery

Backup Tools: rsync, tar, dd, Bacula, Amanda.
Recovery: Boot from a live CD/USB, chroot into the system, and
restore from backups.

Troubleshooting Tips:
Backup Verification: Regularly verify backups to ensure they are
complete and usable.
Recovery Planning: Have a documented recovery plan and test it
periodically.
 Debugging Common Linux Issues
Working with Network Tools

Scripting and Automation

Shell Scripting: Bash, Python, Perl.
Automation Tools: cron, anacron, systemd timers.

Troubleshooting Tips:
Script Debugging: Use set -x in Bash scripts for debugging.
Cron Jobs: Check /var/log/cron.log for cron job errors.

Stay Updated and Practice

Stay Informed: Follow Linux forums, mailing lists, and blogs.
Practice: Set up a lab environment using virtual machines (e.g.,
VirtualBox, VMware) to practice troubleshooting scenarios.
 CONTACT US FOR
FURTHER INQUIRIES

Follow Me: https://www.linkedin.com/in/avinash-tietler/

DEVOPS DIARIES
Subscribe My News Letter on LinkedIn