Forem: Aryan Vaishnani

Managing Groups in Linux

Aryan Vaishnani — Mon, 25 May 2026 10:17:21 +0000

Groups are used to manage permissions for multiple users together.

Instead of giving permissions user-by-user, Linux allows assigning permissions to groups.

Main commands:

groupadd
groupmod
gpasswd

What is a Group?

A group is a collection of users.

Example:

Developers group
Docker group
Admin group

Group Information File

Linux stores group data in:

/etc/group

View Groups

cat /etc/group

Example Entry

docker:x:999:aryan

1. groupadd Command

Purpose

Creates a new group.

Syntax

sudo groupadd groupname

Example

sudo groupadd developers

Creates:

developers

group.

Create Group with Custom GID

sudo groupadd -g 2000 devops

Real-World Usage

Create Docker Team Group

sudo groupadd dockerteam

2. groupmod Command

Purpose

Modifies existing group.

Syntax

sudo groupmod options groupname

Rename Group

sudo groupmod -n engineers developers

Meaning:

developers → engineers

Change Group ID

sudo groupmod -g 3000 engineers

Real-World Usage

Rename Team Group

sudo groupmod -n sre_team devops

3. gpasswd Command

Purpose

Manages group members and passwords.

Add User to Group

sudo gpasswd -a aryan docker

Meaning:

Add aryan to docker group

Remove User from Group

sudo gpasswd -d aryan docker

Set Group Administrator

sudo gpasswd -A aryan developers

Primary vs Secondary Groups

Type	Purpose
Primary Group	Main group of user
Secondary Group	Extra permission groups

Example

uid=1000(aryan) gid=1000(aryan) groups=1000(aryan),999(docker)

Add User to Multiple Groups

sudo usermod -aG docker,sudo devuser

Important Groups in Linux

Group	Purpose
sudo	Administrative access
docker	Docker permissions
wheel	Admin access in RHEL
www-data	Web server user
adm	Log access

Useful Group Commands

Command	Purpose
groupadd	Create group
groupmod	Modify group
groupdel	Delete group
gpasswd	Manage group members
groups	Show user groups
id	Show UID/GID

Creating & Deleting Users (useradd, userdel, usermod)

Aryan Vaishnani — Mon, 25 May 2026 10:11:24 +0000

Linux provides commands to:

Create users
Modify users
Delete users
Manage groups and permissions

Main commands:

useradd
userdel
usermod

1. useradd Command

Purpose

Creates a new user account.

Basic Syntax

sudo useradd username

Example

sudo useradd devuser

Creates:

User account
Entry in /etc/passwd

Set Password

sudo passwd devuser

Create User with Home Directory

sudo useradd -m devuser

m creates:

/home/devuser

Create User with Shell

sudo useradd -m -s /bin/bash devuser

Important Options

Option	Purpose
-m	Create home directory
-s	Set login shell
-G	Add supplementary groups
-u	Custom UID

Add User to Multiple Groups

sudo useradd -m -G docker,sudo devuser

Real-World Usage

Create DevOps User

sudo useradd -m -G docker,sudo devops

2. userdel Command

Purpose

Deletes a user account.

Basic Syntax

sudo userdel username

Example

sudo userdel devuser

Removes:

User account entry

But home directory may remain

Delete User with Home Directory

sudo userdel -r devuser

r removes:

Home directory
Mail spool

Real-World Usage

Remove Temporary Employee Account

sudo userdel -r intern1

Important Note

Never delete system users carelessly.

3. usermod Command

Purpose

Modifies existing user accounts.

Basic Syntax

sudo usermod options username

Change Username

sudo usermod -l newname oldname

Change Home Directory

sudo usermod -d /new/home devuser

Add User to Group

sudo usermod -aG docker devuser

Meaning:

a = append
G = supplementary group

Important Warning

Wrong command:

sudo usermod -G docker devuser

This removes existing groups.

Correct usage:

sudo usermod -aG docker devuser

Lock User Account

sudo usermod -L devuser

Unlock User Account

sudo usermod -U devuser

Change Shell

sudo usermod -s /bin/zsh devuser

Real-World DevOps Examples

Give Docker Access

sudo usermod -aG docker aryan

Give Sudo Access

Ubuntu/Debian:

sudo usermod -aG sudo devuser

RHEL/CentOS:

sudo usermod -aG wheel devuser

Useful User Commands

Check Current User

whoami

Show User Details

id devuser

Show Groups

groups devuser

Switch User

su - devuser

Check User Files

cat /etc/passwd

understanding /etc/passwd, /etc/shadow, /etc/group

Aryan Vaishnani — Mon, 25 May 2026 10:04:31 +0000

These are important Linux system files used for:

User management
Authentication
Password storage
Group permissions

1. /etc/passwd

Purpose

Stores basic user account information.

View File

cat /etc/passwd

Example Entry

aryan❌1001:1001:Aryan:/home/aryan:/bin/bash

Fields Explanation

Field	Meaning
aryan	Username
x	Password stored in /etc/shadow
1001	User ID (UID)
1001	Group ID (GID)
Aryan	Comment/full name
/home/aryan	Home directory
/bin/bash	Default shell

Important Notes

UID Meaning

UID	Purpose
0	Root user
1-999	System users
1000+	Normal users

Real-World Usage

Check User Shell

grep admin /etc/passwd - Her the admin is username

2. /etc/shadow

Purpose

Stores encrypted passwords and password policies.

Very sensitive file.

View File

Only root can access:

sudo cat /etc/shadow

Example Entry

aryan:$6$abcxyzhashedpassword:19800:0:99999:7:::

Fields Explanation

Field	Meaning
aryan	Username
$6$...	Encrypted password
19800	Last password change
0	Minimum password age
99999	Maximum password age
7	Warning days before expiry

Password Hash Types

Prefix	Algorithm
$1$	MD5
$5$	SHA-256
$6$	SHA-512

Security Importance

/etc/shadow permissions:

ls -l /etc/shadow

Usually:

r-------- root root

Only root can read it.

Real-World Usage

Check Password Expiry

sudo chage -l vagrant - vagrant is username.

3. /etc/group

Purpose

Stores group information.

Groups help manage permissions for multiple users.

View File

cat /etc/group

Example Entry

docker:x:999:aryan

Fields Explanation

Field	Meaning
docker	Group name
x	Group password placeholder
999	Group ID (GID)
aryan	Group members

Real-World Usage

Check User Groups

groups aryan - aryan is group name.

Common Linux Groups

Group	Purpose
sudo	Administrative access
docker	Docker permissions
www-data	Web server user
wheel	Admin group (RHEL/CentOS)

Important Commands

Show Current User

whoami

Show User ID

id

Add User

sudo useradd devuser

Set Password

sudo passwd devuser

Add User to Group

sudo usermod -aG docker vagrant

Real-World DevOps Example

Give Docker Permission

sudo usermod -aG docker aryan

Without this:

docker ps

may fail with permission error.

Security Importance

File	Importance
/etc/passwd	User account info
/etc/shadow	Secure password storage
/etc/group	Permission management

Best Practices

Never manually edit /etc/shadow incorrectly
Use vipw for safe editing
Limit sudo access
Use strong password policies
Regularly audit groups and users

USB & External Media Handling

Aryan Vaishnani — Mon, 25 May 2026 09:57:36 +0000

Linux can detect and manage:

USB drives
External hard disks
SSDs
Memory cards
CD/DVD devices

These devices are usually mounted under:

/media

/mnt

Detect Connected USB Devices

List USB Devices

lsusb

Shows connected USB hardware.

Example Output

Bus 001 Device 002: USB Flash Drive

Check Storage Devices

List Disks

lsblk

Example Output

sda      100G
├─sda1    99G
sdb       16G
└─sdb1    16G

Here:

*sdb * is likely the USB drive.

1. Create Mount Point

Before mounting, create a directory:

sudo mkdir /mnt/usb

2. Mount USB Drive

Syntax

sudo mount /dev/sdb1 /mnt/usb

Meaning:

/dev/sdb1 = USB partition
/mnt/usb = mount point

Access USB Files

cd /mnt/usb

ls

3. Check Mounted Devices

df -h

Example Output

/dev/sdb1 16G 2G 14G

4. Unmount USB Drive

Before removing device:

sudo umount /mnt/usb

sudo umount /dev/sdb1

Important

Never remove USB storage without unmounting.

Otherwise:

Data corruption may happen
Files may be damaged

5. Automatic Mounting

Modern Linux distributions automatically mount USB drives under:

/media/username/

Example

/media/aryan/MyUSB

6. Filesystem Types

Common USB filesystem formats:

Filesystem	Usage
vfat/FAT32	Windows compatibility
exFAT	Large USB storage
NTFS	Windows drives
ext4	Linux native filesystem

Check Filesystem Type

lsblk -f

7. Format USB Drive

EXT4 Format

sudo mkfs.ext4 /dev/sdb1

FAT32 Format

sudo mkfs.vfat /dev/sdb1

Warning

Formatting deletes all data.

8. Safely Remove Device

After unmounting:

udisksctl power-off -b /dev/sdb

Safely powers off USB device.

Real-World Usage

Backup Logs to External Disk

cp /var/log/syslog /mnt/usb

Transfer Kubernetes YAML Files

cp *.yaml /mnt/usb

Store Database Backups

mysqldump database > /mnt/usb/backup.sql

Useful Commands Summary

Command	Purpose
lsusb	Show USB devices
lsblk	Show disks
mount	Mount device
umount	Unmount device
df -h	Disk usage
mkfs.ext4	Format ext4
mkfs.vfat	Format FAT32

Common Mount Locations

Directory	Usage
/media	Auto-mounted devices
/mnt	Manual mounts

Best Practices

Always unmount before removal
Verify device name before formatting
Use df -h to confirm mount
Avoid mounting unknown USB devices on servers
Use proper filesystem types for compatibility.

Mount Points in Linux

Aryan Vaishnani — Mon, 25 May 2026 09:51:32 +0000

What is a Mount Point?

A mount point is a directory where a storage device or filesystem is attached in Linux.

Linux connects disks inside the filesystem tree instead of using drive letters like Windows.

Example

Device:

/dev/sdb1

Mounted on:

/mnt/data

After mounting, files inside the disk are accessible through:

/mnt/data

Basic Mount Command

mount /dev/sdb1 /mnt/data

Meaning:

/dev/sdb1 = disk/partition
/mnt/data = mount point

Common Mount Point Directories

Directory	Purpose
/mnt	Temporary mounts
/media	USB/CD devices
/	Root filesystem
/home	Separate user partition
/boot	Boot partition

Check Mounted Filesystems

mount

df -h

Real-World Example

Mount USB Drive

sudo mount /dev/sdb1 /mnt/usb

Access files:

cd /mnt/usb

Unmount Filesystem

umount /mnt/usb

umount /dev/sdb1

Important Note

You cannot safely remove a disk before unmounting it.

Automatic Mounting

Linux stores permanent mount information in:

/etc/fstab

Example:

/dev/sdb1 /data ext4 defaults 0 0

Real-World Usage

Mount points are heavily used in:

Cloud servers
Docker storage
Kubernetes volumes
External disks
NFS shared storage
Backup systems

Common Filesystem Types

Filesystem	Usage
ext4	Linux standard
xfs	Enterprise systems
vfat	USB compatibility
nfs	Network storage

Best Practices

Always unmount safely
Use /etc/fstab carefully
Monitor disk usage with df -h
Use proper permissions on mounted storage

Hidden Files & Directories in Linux

Aryan Vaishnani — Mon, 25 May 2026 09:47:40 +0000

In Linux, files or directories starting with a dot (.) are hidden.

Example:

.bashrc
.gitconfig
.ssh

These files are usually used for:

Configuration
User settings
Application data
System customization

Why Hidden Files Exist

Hidden files help keep:

Configuration files separate
Home directory clean
System settings protected from accidental changes

Examples of Hidden Files

File	Purpose
.bashrc	Bash shell configuration
.profile	User login settings
.gitconfig	Git configuration
.ssh	SSH keys and configs
.vimrc	Vim editor settings

View Hidden Files

Normal ls does not show hidden files.

Use:

ls -a

Example Output

.bashrc
.profile
.ssh
Documents
Downloads

Detailed Hidden File View

ls -la

Shows:

Hidden files
Permissions
Owner
File size

Create Hidden File

Add . before filename.

Example:

touch .secret

Create Hidden Directory

mkdir .config
Access Hidden Directory

cd .config

Real-World Usage

SSH Configuration

cd ~/.ssh

Contains:

id_rsa
authorized_keys
config

Git Configuration

cat ~/.gitconfig

Bash Configuration

nano ~/.bashrc

Common for:

Aliases
PATH variables
Shell customization

Hide Existing File

Rename file with dot.

Example:

mv notes.txt .notes.txt

Now file becomes hidden.

Find Hidden Files

find . -name ".*"

Important Hidden Directories

Directory	Purpose
~/.ssh	SSH keys
~/.config	App configs
~/.kube	Kubernetes configs
~/.docker	Docker configs
~/.git	Git repository data

Real-World DevOps Example

Kubernetes Config

ls ~/.kube

Contains:

config

Used by:

kubectl

Important Notes

Hidden Does NOT Mean Secure

Hidden files are only visually hidden.

Anyone with permissions can still access them.

Example

cat .secret

still works.

Best Practices

Do not delete hidden files carelessly
Backup configuration files
Protect sensitive hidden files with permissions
Use hidden directories for configs only

Quick Commands Summary

Command	Purpose
ls -a	Show hidden files
ls -la	Detailed hidden files
touch .file	Create hidden file
mkdir .dir	Create hidden directory
mv file .file	Hide file

Absolute vs Relative Paths

Aryan Vaishnani — Mon, 25 May 2026 09:38:32 +0000

Paths are used to locate files and directories in Linux.

1. Absolute Path

An absolute path starts from the root directory:

It shows the complete location of a file or folder.

Example

/home/aryan/projects/app.py

This path works from anywhere in the system.

2. Relative Path

A relative path starts from the current directory.

It does NOT start with /.

Example

Current directory:

/home/aryan

Command:

cd projects

Linux understands:

/home/aryan/projects

Special Symbols

Symbol	Meaning
.	Current directory
..	Parent directory
~	Home directory

Examples

Current Directory

./script.sh

Parent Directory

cd ..

Home Directory

cd ~

Difference Table

Absolute Path	Relative Path
Starts with /	Does not start with /
Full location	Based on current location
Works everywhere	Depends on current directory
Longer	Shorter

Real-World Example

Current directory:

/var/log

Relative Path

cd nginx

Absolute Path

cd /var/log/nginx

Both go to same directory.

Easy Trick

Absolute Path = Full address
Relative Path = Nearby shortcut

File Types (Regular, Directory, Link, Device, Socket, Pipe)

Aryan Vaishnani — Mon, 25 May 2026 09:36:03 +0000

In Linux, everything is treated as a file.

Linux supports different file types for:

Data storage
Directories
Hardware devices
Communication
Inter-process communication

Main Linux File Types

File Type	Symbol	Purpose
Regular File	-	Store data
Directory	d	Store files/folders
Symbolic Link	l	Point to another file
Character Device	c	Character-based devices
Block Device	b	Block storage devices
Socket	s	Process communication
Named Pipe (FIFO)	p	Data transfer between processes

Check File Types

Use:

ls -l

Example output:

rw-r--r-- file.txt

drwxr-xr-x documents

lrwxrwxrwx link -> file.txt

The first character shows the file type.

1. Regular File -

Purpose

Stores:

Text
Scripts
Images
Programs
Logs

Examples

file.txt
script.sh
app.log
image.png

Example Output

rw-r--r-- file.txt
indicates regular file.

Real-World Usage

Log Files

/var/log/syslog

Shell Scripts

backup.sh

2. Directory d

Purpose

Stores:

Files
Other directories

Example

drwxr-xr-x projects

d indicates directory.

Common Directories

/home
/etc
/var

Real-World Usage

Kubernetes Manifests Folder

mkdir k8s

3. Symbolic Link l

Purpose

Points to another file or directory.

Similar to shortcuts in Windows.

Create Symbolic Link

ln -s original.txt link.txt

Example Output

lrwxrwxrwx link.txt -> original.txt

l indicates symbolic link.

Real-World Usage

Application Deployment

ln -s /opt/app/current current_app

Very common in DevOps deployments.

Benefits

Easy version switching
Shared configurations
Flexible file management

4. Character Device File c

Purpose

Handles character-by-character device communication.

Examples

/dev/tty
/dev/random

Example Output

crw-rw-rw- /dev/tty

c indicates character device.

Real-World Usage

Keyboard Input

/dev/tty

Random Number Generator

/dev/random

5. Block Device File b

Purpose

Represents block storage devices.

Data transferred in blocks.

Examples

/dev/sda
/dev/nvme0n1

Example Output

brw-rw---- /dev/sda

b indicates block device.

Real-World Usage

Disk Management

lsblk

Shows block devices.

Used For

Hard disks
SSDs
USB drives

6. Socket File s

Purpose

Used for communication between processes.

Examples

/var/run/docker.sock

Example Output

srw-rw---- docker.sock

s indicates socket.

Real-World Usage

Docker Communication

/var/run/docker.sock

Docker client communicates with Docker daemon through socket.

Common Services Using Sockets

Docker
MySQL
Nginx
systemd

7. Named Pipe (FIFO) p

Purpose

Used for inter-process communication.

FIFO = First In First Out

Create Named Pipe

mkfifo mypipe

Example Output

prw-r--r-- mypipe

p indicates pipe.

Real-World Usage

Process Communication

One process writes:

echo "Hello" > mypipe

Another reads:

cat mypipe

File Type Symbols Summary

Symbol	File Type
-	Regular file
d	Directory
l	Symbolic link
c	Character device
b	Block device
s	Socket
p	Named pipe

Useful Commands for File Types

Identify File Type

file filename

Example

file script.sh

Output:

Bourne-Again shell script

List Detailed File Types

ls -l

Find Specific File Types

Find Symbolic Links

find . -type l

Find Directories

find . -type d

Find Regular Files

find . -type f

Linux Directory Structure (/bin, /etc, /var, /home, /usr, /tmp)

Aryan Vaishnani — Mon, 25 May 2026 09:29:43 +0000

Linux Directory Structure

Linux follows a standard filesystem hierarchy where every file and directory starts from the root directory:

This structure is called the:

Filesystem Hierarchy Standard (FHS)

Root Directory /

The top-level directory in Linux.

Everything exists under:

Example:

/home
/etc
/var
/usr

Linux Directory Tree

/
├── bin
├── boot
├── dev
├── etc
├── home
├── lib
├── media
├── mnt
├── opt
├── proc
├── root
├── run
├── sbin
├── srv
├── sys
├── tmp
├── usr
└── var

Important Linux Directories

1. /bin

Meaning

Essential user binaries (commands).

Contains basic commands required for system operation.

Examples

/bin/ls
/bin/cp
/bin/mv
/bin/bash

Real-World Usage

Commands available even in recovery mode.

2. /sbin

Meaning

System binaries.

Contains administrative commands mainly used by root user.

Examples

/sbin/reboot
/sbin/fsck
/sbin/ip

Used For

System repair
Networking
Boot management

3. /boot

Meaning

Boot-related files.

Contains:

Linux kernel
Bootloader files
initramfs

Examples

/boot/vmlinuz
/boot/grub

Real-World Importance

Critical for system startup.

4. /dev

Meaning

Device files.

Linux treats hardware devices as files.

Examples

/dev/sda
/dev/null
/dev/tty

Important Devices

Device	Purpose
/dev/sda	Hard disk
/dev/null	Discard output
/dev/random	Random generator

Real-World Usage

Redirect Output

command > /dev/null

5. /etc

Meaning

System configuration files.

One of the most important directories.

Examples

/etc/passwd
/etc/hosts
/etc/nginx/
/etc/ssh/

Real-World Usage

Edit SSH Config

vim /etc/ssh/sshd_config

6. /home

Meaning

User home directories.

Example

/home/aryan
/home/user1

Contains

Documents
Downloads
User configs
Scripts

Hidden Files Example

/home/user/.bashrc

7. /root

Meaning

Home directory of root user.

Example

/root

Difference

Directory	Purpose
/home/user	Normal user
/root	Root administrator

8. /lib and /lib64

Meaning

Shared libraries required by programs.

Similar to DLL files in Windows.

Examples

/lib/modules
/lib64/libc.so

Real-World Importance

Programs depend on these libraries.

9. /usr

Meaning

User applications and utilities.

Largest directory in many systems.

Important Subdirectories

Path	Purpose
/usr/bin	User commands
/usr/sbin	Admin commands
/usr/lib	Libraries
/usr/share	Shared data

Examples

/usr/bin/python
/usr/bin/docker

10. /var

Meaning

Variable data files.

Data changes frequently here.

Important Subdirectories

Path	Purpose
/var/log	Logs
/var/cache	Cache
/var/www	Web files
/var/spool	Queues

Real-World Usage

View Logs

cd /var/log

Examples

/var/log/syslog

/var/log/nginx/

11. /tmp

Meaning

Temporary files.

Characteristics

Temporary storage
Often cleared on reboot

Example

/tmp/install.tmp

Real-World Usage

Scripts store temporary data here.

12. /proc

Meaning

Virtual filesystem containing process and kernel information.

Examples

/proc/cpuinfo
/proc/meminfo

Real-World Usage

Check CPU Info

cat /proc/cpuinfo

13. /sys

Meaning

Kernel and hardware information.

Used for:

Device management
Kernel tuning

Example

/sys/class
/sys/devices

14. /opt

Meaning

Optional third-party software.

Examples

/opt/google
/opt/app

Real-World Usage

Custom applications installed here.

15. /mnt

Meaning

Temporary mount points.

Example

/mnt/backup

Used For

Mount disks
Attach storage
Temporary filesystems

16. /media

Meaning

Removable media devices.

Examples

/media/usb
/media/cdrom

Used For

USB drives and external devices.

17. /run

Meaning

Runtime process data.

Contains temporary system information.

Examples

/run/docker.sock
/run/systemd/

Real-World Usage

Docker socket communication.

18. /srv

Meaning

Service data provided by system.

Examples

/srv/www
/srv/ftp

Linux Directory Quick Summary

Directory	Purpose
/	Root filesystem
/bin	Essential commands
/sbin	System commands
/boot	Boot files
/dev	Device files
/etc	Configurations
/home	User directories
/root	Root user home
/lib	Libraries
/usr	Applications
/var	Logs and variable data
/tmp	Temporary files
/proc	Process info
/sys	Kernel info
/opt	Optional software
/mnt	Temporary mounts
/media	External media
/run	Runtime data
/srv	Service data

Basic Input/Output Redirection

Aryan Vaishnani — Mon, 25 May 2026 09:18:40 +0000

Input and Output redirection allows Linux users to:

Save command output to files
Read input from files
Combine commands
Redirect errors
Automate workflows

Standard Streams in Linux

Linux processes use three default streams.

Stream	Number	Purpose
STDIN	0	Input
STDOUT	1	Normal output
STDERR	2	Error output

1. Output Redirection >

Purpose

Redirect command output into a file.

Syntax

command > file

Example

ls > files.txt

Instead of showing output on terminal:

Output is saved in:

files.txt

Important Behavior

overwrites file content.

Example

echo "Hello" > test.txt

File content becomes:

Hello

Real-World Usage

Save Process List

ps aux > processes.txt

Export Kubernetes Pods

kubectl get pods > pods.txt

2. Append Output >>

Purpose

Append output to existing file.

Syntax

command >> file

Example

echo "New Log" >> app.log

Adds text to end of file.

Difference Between > and >>

Operator	Behavior
>	Overwrite
>>	Append

Real-World Usage

Append Logs

date >> backup.log

Store Deployment History

kubectl get nodes >> cluster_status.log

3. Input Redirection <

Purpose

Provide file content as input to command.

Syntax

command < file

Example

wc -l < users.txt

Counts lines in file.

Real-World Usage

SQL Script Execution

mysql < database.sql

4. Error Redirection 2>

Purpose

Redirect errors separately.

Syntax

command 2> error.log

Example

ls invalidfile 2> errors.txt

Error saved into:

errors.txt

Real-World Usage

Save Deployment Errors

kubectl apply -f app.yaml 2> deploy_errors.log

5. Redirect STDOUT and STDERR Together

Syntax

command > output.log 2>&1

Meaning

Part	Purpose
>	Redirect stdout
2>&1	Redirect stderr to stdout

Example

docker ps > docker.log 2>&1

Both:

Normal output
Errors

go into same file.

Modern Shortcut

command &> file.log

6. Pipe |

Purpose

Send output of one command as input to another.

Syntax

command1 | command2

Example

ls -l | less

Another Example

ps aux | grep nginx

Process:

ps aux shows processes
Output passed to grep
grep filters nginx processes

Real-World Usage

Kubernetes

kubectl get pods | grep running

Docker

docker ps | grep nginx

7. Tee Command

Purpose

Display output and save to file simultaneously.

Syntax

command | tee file

Example

ls | tee output.txt

Output:

Displays on terminal
Saves in file

Real-World Usage

Save Deployment Logs

kubectl apply -f app.yaml | tee deploy.log

Practical DevOps Examples

Monitor Logs

tail -f app.log | grep ERROR

Save System Information

df -h > disk_usage.txt

Store Failed Services

systemctl status nginx 2> nginx_errors.log

Backup Kubernetes Output

kubectl get all > cluster_backup.txt

Common Redirection Symbols

Symbol	Purpose
>	Redirect output
>>	Append output
<	Redirect input
2>	Redirect errors

tee	Save and display output

Dangerous Mistake

Accidentally Overwriting File

echo "test" > important.txt

This removes old content.

Use:

>>

if appending is needed.

Wildcards & Globbing

Aryan Vaishnani — Mon, 25 May 2026 09:10:05 +0000

Wildcards and globbing are used to match:

File names
Directory names
Patterns

They help users work with multiple files quickly.

What is Globbing?

Globbing is the process where the shell expands wildcard patterns into matching filenames.

Example:

ls *.txt

The shell automatically replaces:

.txt

with all matching .txt files.

Common Wildcards

Wildcard	Meaning
*	Match zero or more characters
?	Match single character
[]	Match character range/set
{}	Match multiple patterns
~	Home directory shortcut

*1. Asterisk **

Meaning

Matches:

zero or more characters

Examples

Match All Files

ls *

Match Text Files

ls *.txt

Matches:

notes.txt
app.txt

Match Log Files

ls *.log

Real-World Usage

Delete Old Logs

rm *.log

Copy All YAML Files

cp *.yaml /backup/

Common in Kubernetes management.

2. Question Mark ?

Meaning

Matches:

exactly one character

Example

ls file?.txt

Matches:

file1.txt
fileA.txt

Does NOT match:

file10.txt

Real-World Usage

Match Numbered Files

ls backup?.tar

3. Square Brackets []

Meaning

Matches specific characters or ranges.

Examples

Match Specific Characters

ls file[123].txt

Matches:

file1.txt
file2.txt
file3.txt

Match Character Range

ls file[a-z].txt

Match Numbers

ls log[0-9].txt

Real-World Usage

Process Multiple Server Configs

cat server[1-5].conf

4. Curly Braces {}

Meaning

Used for pattern expansion.

Example

mkdir {dev,test,prod}

Creates:

dev/
test/
prod/

Multiple Extensions

ls *.{txt,log}

Matches:

app.txt
error.log

Real-World Usage

Create Deployment Structure

mkdir -p app/{logs,config,data}

Creates:

app/logs
app/config
app/data

Very common in DevOps setups.

5. Tilde ~

Meaning

Represents:

home directory

Example

cd ~

Moves to:

/home/user

View Hidden Files with Wildcards

Hidden files start with:

Example:

ls .*

Combining Wildcards

Example

ls backup*.tar.gz

Matches:

backup1.tar.gz
backup_final.tar.gz

Recursive File Operations

Find All YAML Files

find . -name "*.yaml"

Very common in Kubernetes projects.

Practical DevOps Examples

Kubernetes YAML Files

kubectl apply -f *.yaml

Applies all YAML manifests.

Backup Logs

cp /var/log/*.log /backup/

Remove Temporary Files

rm temp*

Deploy Multiple Configs

scp config*.json server:/opt/config/

Command History & Completion

Aryan Vaishnani — Mon, 25 May 2026 09:03:48 +0000

Linux shells like Bash and Z shell provide powerful features for:

Command history
Auto-completion
Faster command execution
Productivity improvement

1. Command History

What is Command History?

Linux stores previously executed commands in a history file.

This allows users to:

Reuse commands
Avoid retyping
Track previous operations
Speed up administration work

View Command History

Basic Command

History

Run Previous Commands

Run Specific History Command

!4

Executes command number 4.

Repeat Last Command

!!

Repeat Last Command Starting with Specific Text

!docker

Runs latest command starting with docker.

History Navigation

Use keyboard:

Key	Purpose
↑	Previous command
↓	Next command

Very commonly used in daily Linux work.

Search History Interactively

Reverse Search

Press:

CTRL + R

Then type:

docker

Searches previous docker commands.

History File Location

For Bash:

~/.bash_history

For Zsh:

~/.zsh_history

Configure History Size

Temporary

HISTSIZE=5000

Permanent

Edit:

nano ~/.bashrc

Add:

export HISTSIZE=10000
export HISTFILESIZE=20000

Reload:

source ~/.bashrc

Ignore Duplicate Commands

Add in .bashrc:

export HISTCONTROL=ignoredups

Clear History

Current Session

history -c

Delete History File

rm ~/.bash_history

Real-World Usage of History

Kubernetes

history | grep kubectl

Find old Kubernetes commands.

Docker

history | grep docker

Troubleshooting

history | grep nginx

Check previous server changes.

2. Command Completion

What is Auto-Completion?

Auto-completion automatically completes:

Commands
File names
Directories
Variables
Kubernetes resources

Mainly done using:

TAB key

Basic Completion Example

Type:

cd Doc

Press:

TAB

Becomes:

cd Documents/

Bash Completion Package

Advanced completion support package.

Install:

Ubuntu/Debian

sudo apt install bash-completion -y

Enable Bash Completion

Edit:

nano ~/.bashrc

Add:

source /usr/share/bash-completion/bash_completion

Reload:

source ~/.bashrc