./root@iblizmuda~$: Blogging site

Thursday, January 30, 2025

Linux 101: Part 8 - System Monitoring and Performance Tuning in Linux

In this eighth part of our Linux 101 series, we will explore System Monitoring and Performance Tuning to help optimize system resources, troubleshoot issues, and improve efficiency.

Why Monitor System Performance?

Monitoring system performance allows you to:

Detect and troubleshoot slowdowns.
Optimize resource usage.
Prevent system crashes and failures.
Ensure servers run efficiently.

Essential System Monitoring Commands

1. Checking System Load and CPU Usage

View real-time CPU and process usage:
```
top
```
Enhanced process monitoring (interactive UI):
```
htop
```
(Install htop if not available: sudo apt install htop or sudo dnf install htop)
Check CPU load averages:
```
uptime
```

2. Checking Memory Usage

View memory usage in MB:
```
free -m
```
Detailed memory usage analysis:
```
vmstat 5
```
(Refreshes every 5 seconds)

3. Checking Disk Usage

Check disk space usage:
```
df -h
```
Check which folders use the most space:
```
du -sh /home/*
```

4. Monitoring Running Processes

List running processes:
```
ps aux
```
Find a specific process:
```
ps aux | grep processname
```
Kill a high-resource-consuming process:
```
kill PID
```

5. Checking Network Usage

View active network connections:
```
netstat -tulnp
```
Monitor real-time network usage:
```
iftop
```
(Install with sudo apt install iftop or sudo dnf install iftop)

Performance Tuning in Linux

1. Optimizing CPU Performance

Change process priority using nice and renice:
```
nice -n 10 command
```
```
renice -n -5 -p PID
```
Limit CPU usage of a process:
```
cpulimit -p PID -l 50
```
(Install with sudo apt install cpulimit)

2. Managing RAM and Swap Space

Clear cached memory:

sync; echo 3 > /proc/sys/vm/drop_caches

Check swap usage:
```
swapon -s
```

Increase swap space:

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

3. Improving Disk Performance

Enable write caching:
```
sudo hdparm -W1 /dev/sda
```
Check disk health:
```
sudo smartctl -a /dev/sda
```
(Install with sudo apt install smartmontools)

4. Managing Services and Startup Applications

List enabled services:
```
systemctl list-units --type=service
```
Disable unwanted services:
```
sudo systemctl disable service-name
```
View startup applications:
```
systemd-analyze blame
```

Automating Performance Monitoring

You can automate system monitoring with tools like cron jobs and log monitoring:

Log system resource usage every 10 minutes:

crontab -e

Add this line:

*/10 * * * * free -m >> /var/log/memory.log

Monitor CPU and memory with sar (install with sudo apt install sysstat):
```
sar -u 5 10
```

Conclusion

System monitoring and performance tuning are essential for maintaining a stable Linux environment. In the next part, we will explore Backup and Recovery Strategies in Linux to ensure data protection and disaster recovery planning.

Stay tuned for Linux 101: Part 9 – Backup and Recovery Strategies in Linux!

Friday, January 17, 2025

Linux 101: Part 7 - Shell Scripting and Automation in Linux

In this seventh part of our Linux 101 series, we will explore Shell Scripting and Automation, which helps automate repetitive tasks and improve efficiency in Linux system administration.

What is Shell Scripting?

A shell script is a file containing a series of commands that are executed by the shell. It allows users to automate tasks, schedule jobs, and simplify system management.

Why Use Shell Scripting?

Automates repetitive tasks.
Reduces manual errors.
Improves efficiency in system administration.
Schedules jobs to run at specific times.

Writing a Basic Shell Script

1. Creating a Script File

Use a text editor to create a new script file:

nano myscript.sh

2. Writing the Script

Add the following lines:

#!/bin/bash
# This is a simple script
echo "Hello, Linux World!"
date

3. Making the Script Executable

chmod +x myscript.sh

4. Running the Script

./myscript.sh

Variables in Shell Scripting

You can store values in variables and use them within the script.

#!/bin/bash
name="Linux User"
echo "Hello, $name!"

Conditional Statements

Shell scripts can use if statements for decision-making.

#!/bin/bash
num=10
if [ $num -gt 5 ]; then
    echo "Number is greater than 5"
else
    echo "Number is 5 or less"
fi

Looping in Shell Scripts

For Loop

#!/bin/bash
for i in {1..5}; do
    echo "Number: $i"
done

While Loop

#!/bin/bash
count=1
while [ $count -le 5 ]; do
    echo "Count: $count"
    count=$((count + 1))
done

Functions in Shell Scripts

Functions help structure scripts into reusable blocks.

#!/bin/bash
hello() {
    echo "Hello, Linux!"
}
hello

Scheduling Tasks with Cron Jobs

Cron jobs allow tasks to be scheduled at specific times.

Editing the Cron Table

crontab -e

Example Cron Job

Run a script every day at midnight:

0 0 * * * /path/to/script.sh

Automating System Maintenance Tasks

Examples of common automation tasks:

Backup important files:

tar -czf backup.tar.gz /home/user/documents

Clean temporary files:
```
rm -rf /tmp/*
```
Monitor system resource usage:
```
free -m >> memory.log
```

Conclusion

Shell scripting and automation are powerful tools in Linux for improving productivity and system efficiency. In the next part, we will cover System Monitoring and Performance Tuning in Linux to optimize system performance.

Stay tuned for Linux 101: Part 8 – System Monitoring and Performance Tuning in Linux!

Wednesday, January 15, 2025

Linux 101: Part 6 - Process and Job Management in Linux

In the sixth part of our Linux 101 series, we will explore process and job management in Linux. Understanding how to manage running processes is crucial for system administration, troubleshooting, and optimizing system performance.

Understanding Linux Processes

A process is a running instance of a program. Every process in Linux is assigned a unique Process ID (PID) and belongs to a user.

Types of Processes:

Foreground processes: Run in the terminal and require user interaction.
Background processes: Run in the background without user interaction.
Daemon processes: System processes that run in the background (e.g., SSH, cron jobs).

Viewing Running Processes

Use these commands to monitor running processes:

View active processes:
```
ps aux
```
View processes dynamically:
```
top
```
or use an improved version:
```
htop
```
View processes for a specific user:
```
ps -u username
```
Find a specific process by name:
```
ps aux | grep processname
```

Managing Processes

Killing a Process

Terminate a process by PID:
```
kill PID
```
Force kill a process:
```
kill -9 PID
```
Kill a process by name:
```
pkill processname
```
Kill all instances of a process:
```
killall processname
```

Changing Process Priority

Every process has a priority value called nice value (ranges from -20 to 19, where -20 is the highest priority and 19 is the lowest).

Start a process with a lower priority:
```
nice -n 10 command
```
Change priority of a running process:
```
renice -n 5 -p PID
```
Check priority of running processes:
```
ps -eo pid,comm,nice
```

Managing Jobs in Linux

Linux allows job control to manage multiple processes in the terminal.

Running and Controlling Jobs

Run a command in the background:
```
command &
```
View background jobs:
```
jobs
```
Bring a background job to the foreground:
```
fg %jobID
```
Suspend a running process: Press Ctrl + Z
Resume a suspended job in the background:
```
bg %jobID
```
Terminate a background job:
```
kill %jobID
```

Monitoring System Performance

Use these commands to analyze CPU, memory, and process usage:

Check system resource usage:
```
vmstat 5
```
Monitor memory usage:
```
free -m
```
View disk usage:
```
df -h
```
Check I/O performance:
```
iostat
```

Conclusion

Managing processes and jobs is essential for system stability and efficiency. In the next part, we will explore Linux Shell Scripting and Automation, which will help you automate tasks and improve productivity.

Stay tuned for Linux 101: Part 7 – Shell Scripting and Automation in Linux!

Tuesday, December 31, 2024

Linux 101: Part 5 - Networking and Security Basics in Linux

In this fifth part of our Linux 101 series, we will explore essential networking concepts and security basics in Linux. Understanding these topics is crucial for managing servers, troubleshooting network issues, and securing a Linux environment.

Understanding Linux Networking

Linux provides various tools and commands to manage and troubleshoot network connections. Below are some fundamental networking concepts:

IP Address: A unique identifier for a device on a network.
Subnet Mask: Defines the network and host portion of an IP address.
Gateway: The router that connects a local network to other networks.
DNS (Domain Name System): Resolves domain names into IP addresses.
MAC Address: The hardware address of a network interface.

Checking Network Configuration

Use the following commands to view network details:

Check IP Address:
```
ip a
```
or
```
ifconfig
```
Check Network Routes:
```
ip route show
```
or
```
route -n
```
Check DNS Configuration:
```
cat /etc/resolv.conf
```

Testing Network Connectivity

Ping a Host (Check if a server is reachable):
```
ping -c 4 google.com
```
Check Open Ports on a System:
```
netstat -tulnp
```
or
```
ss -tulnp
```
Traceroute (Check network path to a destination):
```
traceroute google.com
```
DNS Lookup:
```
nslookup google.com
```
or
```
dig google.com
```

Network Configuration and Management

Assigning an IP Address

Manually set an IP address using:

sudo ip addr add 192.168.1.100/24 dev eth0

Bringing Network Interfaces Up/Down

Disable a network interface:
```
sudo ip link set eth0 down
```
Enable a network interface:
```
sudo ip link set eth0 up
```

Security Basics in Linux

Security is a critical aspect of managing a Linux system. Below are some fundamental security practices:

Managing User Access

Locking a User Account:
```
sudo passwd -l username
```
Unlocking a User Account:
```
sudo passwd -u username
```
Checking Last Login of a User:
```
last username
```

Managing Firewalls

Linux includes built-in firewall tools such as iptables and ufw (Uncomplicated Firewall).

Enable UFW:
```
sudo ufw enable
```
Allow SSH Connections:
```
sudo ufw allow ssh
```
Block a Specific IP Address:
```
sudo ufw deny from 192.168.1.10
```
Check Firewall Rules:
```
sudo ufw status
```

Checking System Logs

Log files store critical system activity and security events.

View Authentication Logs:
```
cat /var/log/auth.log
```
View System Logs:
```
journalctl -xe
```
View Failed Login Attempts:
```
sudo faillog -a
```

Securing SSH

Disable Root Login via SSH: Edit the SSH configuration file:
```
sudo nano /etc/ssh/sshd_config
```
Set:
```
PermitRootLogin no
```
Restart SSH service:
```
sudo systemctl restart sshd
```

Keeping Your System Updated

Regularly update your Linux system to patch security vulnerabilities:

For Debian/Ubuntu:
```
sudo apt update && sudo apt upgrade -y
```
For Fedora/RHEL:
```
sudo dnf update -y
```
For Arch Linux:
```
sudo pacman -Syu
```

Conclusion

This article introduced fundamental Linux networking and security concepts. In the next part, we will cover Linux Process and Job Management to help you manage running applications and system performance.

Stay tuned for Linux 101: Part 6 – Process and Job Management in Linux!

Sunday, September 1, 2024

Linux 101: Part 4 - User and Permission Management in Linux

In the previous parts of our Linux 101 series, we covered the basics of Linux, the file system, and package management. Now, in Part 4, we will focus on user and permission management—essential for maintaining system security and access control.

Understanding Users and Groups

Linux is a multi-user operating system, meaning multiple users can access the system with different permission levels. Users are managed through:

User accounts: Each user has a unique ID (UID) and home directory.
Groups: A collection of users with shared permissions.
Root user: The superuser with full administrative privileges.

Managing Users

1. Adding a New User

To create a new user, use:

sudo adduser username

This command creates a home directory (/home/username) and sets a password.

2. Changing User Password

To update a user's password:

sudo passwd username

3. Deleting a User

To remove a user but keep their files:

sudo deluser username

To remove a user and their home directory:

sudo deluser --remove-home username

Managing Groups

1. Creating a New Group

sudo groupadd groupname

2. Adding a User to a Group

sudo usermod -aG groupname username

3. Viewing User and Group Information

Show current user:
```
whoami
```
Show all users:
```
cat /etc/passwd
```
Show all groups:
```
cat /etc/group
```
Show which groups a user belongs to:
```
groups username
```

File Permissions

Each file and directory in Linux has permission settings that define who can read, write, and execute it. You can check permissions using:

ls -l

Example output:

-rwxr-xr--  1 user group 4096 Jan 1 12:00 script.sh

Breakdown:

Symbol	Meaning
`r`	Read permission
`w`	Write permission
`x`	Execute permission
`-`	No permission

Permissions are divided into three sections:

Owner (user) - First three characters (rwx)
Group - Next three characters (r-x)
Others - Last three characters (r--)

Changing File Permissions

1. Using `chmod`

To change file permissions, use:

chmod 755 script.sh

Breakdown:

7 (Owner: rwx = Read, Write, Execute)
5 (Group: r-x = Read, Execute)
5 (Others: r-x = Read, Execute)

Alternatively, you can add/remove specific permissions:

Add execute permission for owner:
```
chmod u+x script.sh
```
Remove write permission for group:
```
chmod g-w script.sh
```

2. Using `chown`

Change file ownership with:

sudo chown newowner:newgroup file.txt

3. Using `chgrp`

Change group ownership:

sudo chgrp newgroup file.txt

Special Permissions: SUID, SGID, and Sticky Bit

SUID (Set User ID) – Allows a file to be executed with the permissions of the file’s owner.
```
chmod u+s filename
```
SGID (Set Group ID) – Ensures files created within a directory inherit the group.
```
chmod g+s directory
```
Sticky Bit – Ensures only the file owner can delete files in a directory.
```
chmod +t directory
```

Conclusion

Understanding user and permission management is essential for securing a Linux system. In the next part, we will cover Networking and Security Essentials in Linux.

Stay tuned for Linux 101: Part 5 – Networking and Security Basics!

Thursday, August 1, 2024

Linux 101: Part 3 - Managing Software Packages in Linux

In the previous parts of our Linux 101 series, we introduced Linux and explored its file system. Now, in Part 3, we will focus on managing software packages in Linux. Understanding package management is crucial for installing, updating, and removing software efficiently.

What is a Package Manager?

A package manager is a tool that automates the process of installing, upgrading, configuring, and removing software. Different Linux distributions use different package managers. Here are some of the most common ones:

APT (Advanced Package Tool) – Used by Debian-based distributions like Ubuntu and Debian.
DNF/YUM (Dandified Yum) – Used by Fedora, CentOS, and RHEL.
Pacman – Used by Arch Linux.
Zypper – Used by openSUSE.
Snap & Flatpak – Universal package managers that work across different Linux distributions.

Package Management Commands

Below are some essential commands for managing software in different Linux distributions.

APT (Debian & Ubuntu)

Update package list:
```
sudo apt update
```
Upgrade installed packages:
```
sudo apt upgrade
```
Install a package:
```
sudo apt install package-name
```
Remove a package:
```
sudo apt remove package-name
```
Search for a package:
```
apt search package-name
```

DNF/YUM (Fedora, CentOS, RHEL)

Update package list:
```
sudo dnf check-update
```
Install a package:
```
sudo dnf install package-name
```
Remove a package:
```
sudo dnf remove package-name
```
Search for a package:
```
dnf search package-name
```

Pacman (Arch Linux)

Update package database and upgrade system:
```
sudo pacman -Syu
```
Install a package:
```
sudo pacman -S package-name
```
Remove a package:
```
sudo pacman -R package-name
```
Search for a package:
```
pacman -Ss package-name
```

Snap and Flatpak (Universal Package Managers)

Snap

Install Snap:
```
sudo apt install snapd
```
Install a Snap package:
```
sudo snap install package-name
```
Remove a Snap package:
```
sudo snap remove package-name
```

Flatpak

Install Flatpak:
```
sudo apt install flatpak
```
Install a Flatpak package:
```
flatpak install flathub package-name
```
Remove a Flatpak package:
```
flatpak uninstall package-name
```

Keeping Your System Updated

Keeping software up to date is essential for security and performance. Here are some general guidelines:

Regularly update your package lists (apt update, dnf check-update, pacman -Syu).
Upgrade packages (apt upgrade, dnf upgrade, pacman -Syu).
Remove unnecessary packages (apt autoremove, dnf autoremove, pacman -Rns).

Conclusion

Managing software packages in Linux is a fundamental skill that will help you keep your system running smoothly. In the next part of this series, we will cover User and Permission Management in Linux.

Stay tuned for Linux 101: Part 4 – User and Permission Management!

Thursday, January 30, 2025

Linux 101: Part 8 - System Monitoring and Performance Tuning in Linux

Why Monitor System Performance?

Essential System Monitoring Commands

1. Checking System Load and CPU Usage

2. Checking Memory Usage

3. Checking Disk Usage

4. Monitoring Running Processes

5. Checking Network Usage

Performance Tuning in Linux

1. Optimizing CPU Performance

2. Managing RAM and Swap Space

3. Improving Disk Performance

4. Managing Services and Startup Applications

Automating Performance Monitoring

Conclusion

Friday, January 17, 2025

Linux 101: Part 7 - Shell Scripting and Automation in Linux

What is Shell Scripting?

Why Use Shell Scripting?

Writing a Basic Shell Script

1. Creating a Script File

2. Writing the Script

3. Making the Script Executable

4. Running the Script

Variables in Shell Scripting

Conditional Statements

Looping in Shell Scripts

For Loop

While Loop

Functions in Shell Scripts

Scheduling Tasks with Cron Jobs

Editing the Cron Table

Example Cron Job

Automating System Maintenance Tasks

Conclusion

Wednesday, January 15, 2025

Linux 101: Part 6 - Process and Job Management in Linux

Understanding Linux Processes

Types of Processes:

Viewing Running Processes

Managing Processes

Killing a Process

Changing Process Priority

Managing Jobs in Linux

Running and Controlling Jobs

Monitoring System Performance

Conclusion

Tuesday, December 31, 2024

Linux 101: Part 5 - Networking and Security Basics in Linux

Understanding Linux Networking

Checking Network Configuration

Testing Network Connectivity

Network Configuration and Management

Assigning an IP Address

Bringing Network Interfaces Up/Down

Security Basics in Linux

Managing User Access

Managing Firewalls

Checking System Logs

Securing SSH

Keeping Your System Updated

Conclusion

Sunday, September 1, 2024

Linux 101: Part 4 - User and Permission Management in Linux

Understanding Users and Groups

Managing Users

1. Adding a New User

2. Changing User Password

3. Deleting a User

Managing Groups

1. Creating a New Group

2. Adding a User to a Group

3. Viewing User and Group Information

File Permissions

Breakdown:

Changing File Permissions

1. Using chmod

2. Using chown

3. Using chgrp

1. Using `chmod`

2. Using `chown`

3. Using `chgrp`