Directory	Purpose
`/`	Root (starting point)
`/home`	User home folders
`/etc`	Configuration files
`/var`	Logs & variable data
`/opt`	Optional software
`/bin`	Basic commands
`/usr`	User programs

Example:

/home/ec2-user
/etc/nginx/nginx.conf
/var/log/messages

👉 In AWS, logs are often in /var/log

6️⃣ Root User vs Normal User

Root user

Full access
Can do anything
Very dangerous if misused

Normal user (Recommended)

Limited access
Uses sudo for admin tasks

Example:

sudo yum install nginx

👉 On AWS EC2:

Default user is NOT root
Example users:
- ec2-user (Amazon Linux)
- ubuntu (Ubuntu)

7️⃣ Linux Shell & Terminal

Shell

A program that understands your commands

Common shell:

bash (most common)

Terminal

The place where you type commands

In AWS:

You connect to EC2
You get a terminal
You run Linux commands

8️⃣ Linux vs Windows (Simple Comparison)

Linux	Windows
CLI focused	GUI focused
Lightweight	Heavy
Free	Paid
Best for servers	Best for desktop

AWS = Linux-first

9️⃣ What you should remember from Topic 1

✅ Linux is the backbone of AWS ✅ AWS EC2 mostly runs Linux ✅ Linux is case-sensitive ✅ Know basic directories ✅ Root vs normal user concept

File & Directory Management (Linux)

1️⃣ What is a File & Directory?

File → Stores data Example: app.js, config.yml, log.txt
Directory (folder) → Stores files and other folders Example: /home/ec2-user, /var/log

👉 On AWS EC2, everything you do is inside files & directories.

2️⃣ Current Working Directory

When you open a terminal, you are inside a directory.

Command:

pwd

📌 Shows where you are now

Example output:

/home/ec2-user

Part	Meaning
`-`	File type
`rw-`	Owner permissions
`rw-`	Group permissions
`r--`	Others permissions
`.`	SELinux context (Amazon Linux uses SELinux)

Symbol	Meaning
`-`	Regular file
`d`	Directory
`l`	Symbolic link

4️⃣ Changing Directories

cd folder-name     # go inside folder
cd ..              # go back one level
cd ~               # go to home directory
cd /               # go to root

Example:

cd /var/log

5️⃣ Absolute vs Relative Paths (VERY IMPORTANT)

Absolute Path

Starts from /
Works from anywhere

Example:

/home/ec2-user/app/config.yml

Relative Path

Based on current directory

Example:

config.yml
../logs/app.log

👉 In AWS scripts, absolute paths are safer.

6️⃣ Creating Files & Directories

touch file.txt         # create empty file
mkdir folder           # create folder
mkdir -p a/b/c         # create nested folders

-p → Parents (Create parent directories as needed.)

7️⃣ Copying Files & Directories

cp file1 file2         # copy file
cp file folder/        # copy into folder
cp -r dir1 dir2        # copy directory

First = OLD (source)
Second = NEW (destination)

Example:

cp config.yml backup.yml

8️⃣ Moving & Renaming

mv oldname newname     # rename
mv file folder/        # move

Example:

mv app.log app-old.log

9️⃣ Deleting Files & Directories ⚠

rm file               # delete file
rm -r folder          # delete folder
rm -rf folder         # force delete (DANGEROUS)

-r → Recursive (Remove the folder and everything inside it, recursively)
-f → Force (Forcefully remove the folder and all its contents recursively, without asking for confirmation)

⚠ Important warning

Linux has NO recycle bin
rm -rf / can destroy the system

👉 Be extra careful on production EC2 servers.

🔟 Useful Shortcuts

cd .     # current directory
cd ..    # parent directory
cd ~     # home directory
cd /     # root directory

1️⃣1️⃣ What you must remember (Exam + Real AWS)

✅ Linux has no GUI on EC2 ✅ You manage everything via files & folders ✅ Paths matter (case-sensitive) ✅ rm -rf is dangerous ✅ Absolute paths are safer in AWS scripts

File Viewing & Editing (Linux)

1️⃣ Why this topic is important for AWS?

On AWS EC2, you will:

Read log files
Edit configuration files
Check application output
Debug errors

2️⃣ Viewing File Content (Basic)

`cat` – show entire file

cat file.txt

Use when:

File is small

⚠ Not good for large log files.

`less` – best command (recommended)

less file.txt

Controls:

↑ ↓ → scroll
Space → next page
/error → search
q → quit

more file.txt

Less powerful than less.

3️⃣ Viewing Part of a File

`head` – beginning of file

head file.txt
head -n 20 file.txt

-n → Number of lines (Show N number of lines, by defult 10).

`tail` – end of file

tail file.txt
tail -n 50 file.txt

🔥 `tail -f` – LIVE log monitoring (VERY IMPORTANT)

tail -f /var/log/nginx/access.log

-f → Follow (keep following the file and show new lines as they are added)

👉 Used to:

Monitor running applications
Debug live issues on EC2

Press Ctrl + C to stop.

4️⃣ Editing Files in Linux

On AWS EC2, you usually edit files using:

nano (easy)
vi / vim (powerful)

5️⃣ `nano` Editor (Beginner Friendly)

nano file.txt

Controls:

Type → edit
Ctrl + O → save
Enter → confirm
Ctrl + X → exit

👉 Recommended when you are starting AWS.

6️⃣ `vi` Editor (Basic Knowledge Enough)

Open file:

vi file.txt

Modes in `vi`

Normal mode → navigation
Insert mode → editing
Command mode → save/exit

Important commands:

i       → insert mode
Esc     → normal mode
:w      → save
:q      → quit
:wq     → save & quit
:q!     → quit without saving

8️⃣ What you must remember

✅ Use less for reading files ✅ Use tail -f for live logs ✅ Use nano for easy editing ✅ Know basic vi commands ✅ Use sudo for system files

Excellent 👍 Now we are at Topic 4: File Permissions & Ownership. This topic is CRITICAL for AWS. Many EC2 issues happen only because of permissions.

I’ll explain slowly, clearly, and with real AWS examples.

File Permissions & Ownership (Linux)

1️⃣ Why permissions are important in AWS?

On AWS EC2:

Applications fail to start ❌
Scripts don’t run ❌
Logs can’t be written ❌

Most of the time the reason is: 👉 Wrong file permissions

2️⃣ Understanding File Permissions

Run:

ls -l

Example output:

-rwxr-xr-- 1 ec2-user ec2-user  512 app.sh

Let’s break it down.

3️⃣ Permission Structure (Very Important)

-rwx r-x r--
  │    │   │
  │    │   └── Others
  │    └────── Group
  └────────── User (Owner)

Permission letters:

r → read
w → write
x → execute
- → no permission

4️⃣ User, Group, Others

Type	Meaning
User	File owner
Group	Group owner
Others	Everyone else

👉 Linux always checks permissions in this order: User → Group → Others

5️⃣ File vs Directory Permissions

File

r → read file
w → modify file
x → run file (script)

6️⃣ Changing Permissions `chmod` (change mode)

Symbolic mode

chmod u+x file.sh              # add execute to user
chmod g-w file.txt             # remove write from group
chmod o+r file.txt             # add read to others
chmod u=rwx,g=rx,o=r file.txt  # set exact permissions
chmod a+x script.sh            # add execute to all
chmod a-r file.txt             # remove read from all
chmod a=r file.txt             # set read for all
chmod +x script.sh             # add execute to all

a means all (user, group, others)
u means user (owner)
g means group
o means others

Numeric mode (VERY IMPORTANT)

Number	Permission
4	read
2	write
1	execute

Example:

chmod 755 app.sh

Meaning:

User   → 7 (rwx)
Group  → 5 (r-x)
Others → 5 (r-x)

7️⃣ Making a Script Executable (AWS COMMON)

If you see:

permission denied

Fix:

chmod +x script.sh
./script.sh

👉 Common in user-data scripts.

8️⃣ File Ownership `chown` (change owner)

Change owner:

chown user file.txt  # user → new owner (user)

Change owner & group:

chown user:group file.txt  # user → new owner, group → new group

Example (AWS):

sudo chown ec2-user:ec2-user app.log

9️⃣ Why `sudo` is needed

System files are owned by root.

Example:

sudo chmod 644 /etc/nginx/nginx.conf

Without sudo:

Permission denied

🔟 Common AWS Permission Issues

❌ App cannot write logs ❌ Script not executing ❌ Nginx cannot access files ❌ Docker volume permission issues

1️⃣1️⃣ Real AWS Example

ls -l /var/www/html
sudo chown -R nginx:nginx /var/www/html
sudo chmod -R 755 /var/www/html

-R means recursive (apply the command to the folder AND everything inside it)

1️⃣2️⃣ What you MUST remember

Permissions = User | Group | Others
chmod controls access
chown controls ownership
755 is very common in AWS
sudo is required for system files

User & Group Management (Linux)

1️⃣ Why this topic is important for AWS?

On AWS EC2:

Multiple people may access one server
Applications should not run as root
Security is very important

👉 Linux users & groups help control access

2️⃣ What is a User?

A user is an account that can:

Login to Linux
Run commands
Own files
Run applications

3️⃣ Root User vs Normal User

Root user

Superuser
Full access
Can break the system

Normal user (Recommended)

Limited permissions
Uses sudo for admin tasks

👉 On AWS:

You login as ec2-user or ubuntu
You use sudo when needed

4️⃣ What is a Group?

A group is a collection of users.

Why groups?

Easier permission management
Used by applications (nginx, docker, etc.)

5️⃣ Important User Commands

Check current user

whoami

User details

id

6️⃣ Creating a User (Admin Task)

sudo useradd devuser
sudo passwd devuser

8️⃣ Deleting a User

sudo userdel devuser

9️⃣ Group Management

Create group

sudo groupadd devgroup

Add user to group

sudo usermod -aG devgroup devuser

Example (AWS common):

sudo usermod -aG docker ec2-user

🔟 AWS Real-Life Examples

Add user for SSH access
Add user to docker group
Restrict access to logs
Avoid using root

Process Management (Linux)

1️⃣ What is a Process?

A process is: 👉 A running program in Linux

Examples:

Nginx running
Java application running
Node.js server running
SSH session running

If a program is running → it has a process ID (PID).

2️⃣ Process ID (PID)

Every process has a unique number called PID.

Example:

nginx → PID 1345
java  → PID 2098

👉 PID is used to monitor or kill a process.

3️⃣ Foreground vs Background Process

Background Process

Runs in background
Terminal is free

Example:

sleep 30 &  # run in background

4️⃣ Sending Process to Background

If a process is running:

Press Ctrl + Z → pause
Then run:

bg

5️⃣ Process States (High-Level)

State	Meaning
R	Running
S	Sleeping
D	Waiting
Z	Zombie
T	Stopped

👉 Zombie processes = badly written apps.

6️⃣ Monitoring Processes

`ps` – process snapshot

ps
output: 
    PID TTY          TIME CMD
  48615 pts/7    00:00:00 bash
  49301 pts/7    00:00:00 sleep
  49303 pts/7    00:00:00 ps

PID (Process ID): Unique identifier for each running process.
TTY (Terminal Type): The terminal associated with the process.
TIME: The amount of CPU time the process has used.
CMD (Command): The command that started the process.

ps aux

What this command means

ps → show running processes
a → processes for all users
u → show user-oriented format (CPU, memory, etc.)
x → include processes not attached to a terminal

Most common:

ps aux | less

ps -p PID # show specific process by PID

`top` – live monitoring (VERY IMPORTANT)

top

Shows:

CPU usage
Memory usage
Running processes

Press q to quit.

7️⃣ Finding a Specific Process

ps aux | grep nginx
ps aux | grep java

Used when:

App is running but not responding

8️⃣ Killing Processes (IMPORTANT)

Graceful stop

kill PID

🔟 AWS Real-Life Examples

Nginx consuming high CPU

top
ps aux | grep nginx
sudo kill PID

1️⃣1️⃣ Background Jobs

List jobs:

jobs

Bring to foreground:

fg

The fg command is used in Linux/Unix shells to resume a stopped or background job and bring it to the foreground.

1️⃣3️⃣ Background Processes in AWS (nohup)

What happens with & (background only)

& runs the command in the background Example:

java -jar EWA-1.0.0.jar > app.log 2>&1 &

✅ What this does:

Runs the app in the background
You can still use the same terminal

❌ What happens when you:

Close SSH
Network disconnects
Session times out

👉 Process gets killed

Why this happens (important)

Processes started with & still receive SIGHUP (hangup signal) when the terminal closes.

Linux says:

“Terminal gone → kill child processes”

What `nohup` does

Example nohup java -jar EWA-1.0.0.jar > app.log 2>&1 &

✅ What this does:

Ignores SIGHUP
Process keeps running after logout
Fully detached from terminal

That’s why nohup = NO HANG UP

Feature	`&`	`nohup &`
Runs in background	✅	✅
Survives SSH logout	❌	✅
Survives network drop	❌	✅
Used on servers	❌ risky	✅ common
Creates `nohup.out`	❌	✅ (if not redirected)

1️⃣2️⃣ What you MUST remember

✅ Process = running program
✅ Every process has PID
✅ top is your best friend
✅ kill stops processes
✅ Use kill -9 carefully
✅ Background processes are common in AWS

Networking Basics (Linux)

1️⃣ IP Address & Hostname

IP Address

An IP address uniquely identifies a machine on a network.

Example:

172.31.12.45

In AWS EC2:

Private IP → inside VPC
Public IP → access from internet

Check IP Address

ip a   # show IP addresses

ifconfig  # older command

Hostname

A hostname is the name of the machine.

Check hostname:

hostname

Set hostname:

sudo hostnamectl set-hostname my-ec2-server

2️⃣ Network Interfaces

A network interface connects your server to the network.

Example:

eth0
ens5

Check interfaces:

ip link

3️⃣ Ports & Services (VERY IMPORTANT)

Port

A port is a communication endpoint.

Common ports:

Port	Service
22	SSH
80	HTTP
443	HTTPS
3306	MySQL
8080	App server

Check Open Ports

netstat -tulnp  # Show all TCP ports that are currently listening, with process info.
or
ss -tulnp  # Modern replacement for netstat

Option	Meaning
`-t`	Show TCP connections only
`-o`	Show timers (retransmit / keepalive info)
`-n`	Show numeric addresses (no DNS lookup)
`-l`	Show listening (server) ports
`-p`	Show PID / program name using the port

output:

State   Recv-Q  Send-Q  Local Address:Port  Peer Address:Port  Process
LISTEN  0       128           0.0.0.0:22         0.0.0.0:*
LISTEN  0       128              [::]:22            [::]:*
LISTEN  0       511                 *:80               *:*
LISTEN  0       100                 *:8080             *:*      users:(("java",pid=51635,fd=19))

Column	Explanation
Proto	Protocol (`tcp`, `tcp6`)
Recv-Q	Data waiting to be read
Send-Q	Data waiting to be sent
Local Address	IP:Port on your server
Foreign Address	Client side (who can connect)
State	Connection state
PID/Program name	Process using the port
Timer	TCP timer info

4️⃣ Connectivity Testing

`ping` – test network reachability

ping google.com
ping 8.8.8.8

Stop with Ctrl + C.

⚠ AWS Security Groups may block ping.

`curl` – test web & APIs (VERY IMPORTANT)

curl http://localhost
curl http://public-ip
curl https://api.example.com

Used to:

Test APIs
Check if app is running

`telnet` / `nc` – test port connectivity

telnet localhost 80
nc -zv localhost 8080

5️⃣ Downloading from Internet

`wget`

wget https://example.com/file.zip

`curl` download

curl -O https://example.com/file.zip

Used in:

App setup
User-data scripts
CI/CD pipelines

6️⃣ AWS Real-Life Debugging Scenario

❌ App not accessible from browser

Steps:

ip a
ss -tulnp
curl localhost

If works locally but not from browser: 👉 Issue is Security Group / NACL, not Linux.

7️⃣ What you MUST remember

✅ IP identifies the server
✅ Ports expose services
✅ ss -tulnp shows listening ports
✅ curl is essential for AWS
✅ Download tools are used everywhere

Disk & Storage Management (Linux)

🧱 What is Disk & Storage Management in Linux?

Disk & Storage Management means:

Detecting disks
Creating partitions
Formatting filesystems
Mounting disks
Managing space
Monitoring disk usage
Handling permissions & performance

👉 In simple words:

It is how Linux stores, organizes, and accesses your data on disks

🖴 Types of Storage Devices in Linux

Device	Example
Hard Disk (HDD)	`/dev/sda`
Solid State Drive (SSD)	`/dev/nvme0n1`
USB Drive	`/dev/sdb`
Virtual Disk (VM / EC2)	`/dev/xvda`

🧭 Disk Naming in Linux

Linux treats everything as a file.

Name	Meaning
`/dev/sda`	First disk
`/dev/sda1`	First partition
`/dev/sdb`	Second disk
`/dev/nvme0n1p1`	NVMe partition

Check disks:

lsblk

📦 Partitions (Why needed?)

A partition divides a disk into logical sections.

Example:

Disk: 1 TB
Partition 1: OS
Partition 2: Home
Partition 3: Backup

View partitions:

lsblk
fdisk -l

🛠 Partitioning Tools

Tool	Use
`fdisk`	MBR partitions
`cfdisk`	Menu based
`parted`	GPT partitions
`lsblk`	Display structure

Create partition (example):

sudo fdisk /dev/sdb

Common fdisk commands:

n → new partition
p → print table
w → write changes

🧬 Filesystem (VERY IMPORTANT)

A filesystem defines how data is stored & retrieved.

Filesystem	Use
ext4	Default Linux
xfs	High performance
ntfs	Windows
vfat	USB drives

Format partition:

sudo mkfs.ext4 /dev/sdb1

📌 Mounting (Make storage usable)

Linux needs to mount a disk to access it.

Temporary Mount

sudo mount /dev/sdb1 /mnt/data

Check mounts:

df -h
mount

Unmount:

sudo umount /mnt/data

📊 Disk Usage Monitoring

Check disk space

df -h

Check folder size

du -sh /var/log

Find large files

find / -size +1G

📂 Inodes (Often ignored but important)

Each file uses an inode.

Check inode usage:

df -i

Problem:

Disk shows free space but still “No space left”

Cause:

Inodes exhausted

🔐 Permissions & Ownership

Check:

ls -l

Format:

-rwxr-xr--

Change owner:

sudo chown user:group file

Change permission:

chmod 755 file

🔥 Logical Volume Management (LVM)

LVM allows:

Resize disks
Combine multiple disks
Snapshot backups

LVM Components

Component	Meaning
PV	Physical Volume
VG	Volume Group
LV	Logical Volume

Commands:

pvcreate /dev/sdb
vgcreate vg_data /dev/sdb
lvcreate -L 10G -n lv_data vg_data

Format & mount:

mkfs.ext4 /dev/vg_data/lv_data
mount /dev/vg_data/lv_data /data

☁️ Disk Management in Cloud (AWS EC2)

List disks:

lsblk

Extend EBS volume:

growpart /dev/xvda 1
resize2fs /dev/xvda1

🧯 Disk Errors & Health

Check filesystem:

fsck /dev/sdb1

SMART health:

smartctl -a /dev/sda

🚨 Common Disk Problems

Issue	Reason
Disk full	Logs, backups
Boot failure	Wrong fstab
Slow IO	HDD / high load
Read-only FS	Disk error

🧠 Important Linux Directories

Path	Purpose
`/`	Root
`/home`	User data
`/var`	Logs
`/tmp`	Temporary
`/boot`	Boot files

🧪 Real-World Example

Production server is down due to disk full

Steps:

df -h
du -sh /var/*
rm -rf /var/log/*.gz

🎯 Interview-Ready Questions

Q: What is the difference between partition & filesystem?

Partition divides disk
Filesystem organizes data

Q: What is LVM?

Logical Volume Manager used to resize and manage disks dynamically

Q: What happens if fstab is wrong?

System may fail to boot

🧾 Must-Know Commands (Cheat Sheet)

lsblk
df -h
du -sh
mount
umount
fdisk
mkfs
fsck
chmod
chown

Package Management (Linux)

📦 What is Package Management?

Package Management is the system used to:

Install software
Update software
Remove software
Manage dependencies
Keep software secure and up to date

👉 In simple words:

It is how Linux installs and manages software safely

🧠 What is a Package?

A package is:

A compiled application
With configuration files
With dependency information
With version details

🏗 Why Package Management Exists

Without package management:

Manual downloads
Dependency hell
Broken systems

With package management:

Automatic dependency resolution
Central repositories
Security updates

🗂 Package Management Components

Component	Purpose
Package	Software unit
Repository	Software source
Package Manager	Tool to manage packages
Dependency	Required packages

🧰 Common Linux Package Managers

Package Manager	Linux Distribution
`yum` / `dnf`	Amazon Linux, RHEL, CentOS
`apt`	Ubuntu, Debian
`pacman`	Arch Linux
`zypper`	SUSE

👉 Amazon Linux is most common in AWS, so focus mainly on yum / dnf, but know apt basics.

1️⃣ `yum` – (Amazon Linux, RHEL, CentOS)

🔹 What is `yum`?

yum = Yellowdog Updater Modified It downloads software from repositories, resolves dependencies, and installs packages.

🔹 Update package list

sudo yum check-update

What it does:

Checks for available updates
Does NOT install anything

📌 Use before upgrading servers in AWS.

🔹 Install a package

sudo yum install nginx

Meaning:

install → install software
nginx → package name

AWS examples:

sudo yum install httpd      # Apache web server
sudo yum install docker    # Docker
sudo yum install git       # Git

🔹 Install without confirmation

sudo yum install nginx -y

-y = yes automatically

📌 Very common in EC2 user-data scripts

🔹 Remove a package

sudo yum remove nginx

Remove unused deps

sudo yum autoremove

Removes software (not always config files).

🔹 Update all packages

sudo yum update

sudo yum update -y

📌 Used during EC2 patching & security updates.

🔹 List installed packages

yum list installed

To check what you installed recently:

yum history

🔹 Check if a package is installed

yum list installed nginx

🔹 Clean cache

sudo yum clean all

Clears downloaded package cache.

📌 Used when yum behaves incorrectly.

2️⃣ `dnf` – (Amazon Linux 2023)

🔹 What is `dnf`?

dnf = Dandified YUM It is the modern replacement for yum.

👉 Commands are almost the same.

sudo dnf install nginx
sudo dnf remove nginx
sudo dnf update -y
dnf search docker
dnf info nginx

📌 If AWS exam mentions Amazon Linux 2023 → think dnf.

3️⃣ `apt` – (Ubuntu on EC2)

🔹 Update package index (VERY IMPORTANT)

sudo apt update

📌 Always run this before installing anything.

🔹 Install a package

sudo apt install nginx

🔹 Install with auto yes

sudo apt install nginx -y

🔹 Remove a package

sudo apt remove nginx

Remove + config:

sudo apt purge nginx

🔹 Upgrade installed packages

sudo apt upgrade

sudo apt upgrade -y

🔹 Full upgrade (handles dependencies)

sudo apt full-upgrade

🔹 Search package

apt search docker

🔹 Show package info

apt show nginx

🔹 List installed packages

apt list --installed

4️⃣ Repository Management (AWS Important)

🔹 What is a repository?

A repo is a server that stores packages.

AWS examples:

Amazon Linux repos
EPEL (Extra Packages for Enterprise Linux)

🔹 List yum repositories

yum repolist

dnf repolist

5️⃣ Package Files (`rpm` & `dpkg`)

🔹 DPKG (Ubuntu)

dpkg -l

dpkg -l nginx

6️⃣ Real AWS EC2 Examples 🔥

🔹 Install web server on EC2 (Amazon Linux)

sudo yum update -y
sudo yum install httpd -y
sudo systemctl start httpd
sudo systemctl enable httpd

🔹 Install Docker on EC2

sudo yum install docker -y
sudo systemctl start docker
sudo systemctl enable docker

🔹 EC2 User-Data Script Example

#!/bin/bash
yum update -y
yum install httpd -y
systemctl start httpd

📌 Package commands are heavily used in user-data.

7️⃣ AWS Exam Focus (Remember This)

✅ Know which OS uses which package manager
✅ Understand install, remove, update, search
✅ Know -y flag
✅ Know amazon-linux-extras
✅ Know difference between yum / dnf / apt

🧠 Simple Rule to Remember

Amazon Linux → yum / dnf Ubuntu → apt

🎯 Interview-Ready Questions

Q: What is a package manager?

A tool that installs, updates, removes, and manages software along with its dependencies.

Q: Difference between apt & yum?

apt → Debian based
yum/dnf → RHEL based

Q: What is a repository?

A centralized storage location for packages.

🏁 Final Summary

Package management in Linux ensures safe, fast, and dependency-aware software installation and maintenance, making Linux systems stable and secure.

Service Management (systemd)

🔧 What is Service Management?

Service Management means:

Starting services (like nginx, mysql, ssh)
Stopping services
Restarting services
Enabling services at boot
Checking service health

👉 In simple words:

It is how Linux runs and controls background programs (services/daemons)

🧠 What is `systemd`?

systemd is the service manager in Linux.

The init system of modern Linux
The first process started by the kernel
Runs with PID 1

It:

Starts services
Stops services
Restarts services
Starts services automatically at boot Check:

ps -p 1

Output:

systemd

🔹 Main command: `systemctl`

systemctl = system control

This is the only command you need to manage services.

🔄 What is a Service / Daemon?

A service (daemon) is a program that:

Runs in background
Starts at boot (optional)
Provides functionality

Examples:

ssh → Remote login
nginx → Web server
docker → Container engine
mysql → Database

🗂 systemd Unit Types

systemd manages units.

Unit Type	Extension	Purpose
Service	`.service`	Background services
Socket	`.socket`	Socket activation
Target	`.target`	Group of units
Mount	`.mount`	Mount points
Timer	`.timer`	Scheduled jobs

1️⃣ Start a Service

sudo systemctl start httpd

Meaning:

start → start the service now
httpd → service name

📌 After starting, service runs until reboot (unless enabled).

2️⃣ Stop a Service

sudo systemctl stop httpd

Stops the service immediately.

📌 Website goes down if web server stops.

3️⃣ Restart a Service (VERY COMMON)

sudo systemctl restart httpd

Used when:

Config file changes
App update
Debugging issues

📌 Most used command in real AWS work.

restart	reload
Stops & starts service	Reloads config only
Causes short downtime	No downtime

5️⃣ Check Service Status ⭐ (MOST IMPORTANT)

systemctl status httpd

Shows:

Is service running?
Error messages
Logs (last lines)
PID

📌 First command to run when something breaks

6️⃣ Enable Service at Boot (AWS CRITICAL)

sudo systemctl enable httpd

Meaning:

Service starts automatically when EC2 reboots

📌 Without this:

After EC2 restart → website DOWN ❌

8️⃣ Start + Enable Together

sudo systemctl enable --now httpd

Meaning:

Start service now
Enable it for boot

📌 Clean & professional command.

9️⃣ List All Services

🔹 All running services

systemctl list-units --type=service

🔹 All services (enabled + disabled)

systemctl list-unit-files --type=service

1️⃣1️⃣ Check if Service is Active

systemctl is-active httpd

Output:

active
inactive
failed

1️⃣2️⃣ View Service Logs (AWS Debugging)

journalctl -u httpd

Last logs only:

journalctl -u httpd -n 20

Live logs:

journalctl -u httpd -f

📌 Used when:

Service fails to start
Port issues
Permission issues

1️⃣3️⃣ Common AWS Services & Names

Service	Name
Apache	`httpd`
Nginx	`nginx`
Docker	`docker`
SSH	`sshd`
Cron	`crond`

📌 Service name ≠ package name sometimes.

1️⃣4️⃣ Real AWS EC2 Examples 🔥

✅ Install & run Apache (Amazon Linux)

sudo yum install httpd -y
sudo systemctl start httpd
sudo systemctl enable httpd

✅ After config change

sudo vi /etc/httpd/conf/httpd.conf
sudo systemctl restart httpd

✅ Debug service failure

systemctl status httpd
journalctl -u httpd

1️⃣5️⃣ User-Data Script Example (AWS)

#!/bin/bash
yum install httpd -y
systemctl start httpd
systemctl enable httpd

📌 systemctl works perfectly in user-data

1️⃣6️⃣ systemd Files (High Level – Exam Only)

Service files location:

/etc/systemd/system/
/usr/lib/systemd/system/

Example file:

httpd.service

You usually DON’T edit these in AWS, just manage them.

1️⃣7️⃣ systemd vs init (Interview / Exam)

init	systemd
Old	Modern
Slow	Fast
No dependency mgmt	Dependency aware

🧠 One-line Rule

Install → Start → Enable → Check Status

🧩 Service States

State	Meaning
active (running)	Service is running
inactive	Not running
failed	Crashed
enabled	Starts at boot
disabled	Manual start

⚙️ Anatomy of a Service File

Location:

/lib/systemd/system/

/etc/systemd/system/

Example: myapp.service

[Unit]
Description=My Custom App
After=network.target

[Service]
ExecStart=/usr/bin/python3 /app/main.py
Restart=always
User=ec2-user

[Install]
WantedBy=multi-user.target

🧠 Key Sections Explained

🔁 Reload systemd (IMPORTANT)

After editing service file:

sudo systemctl daemon-reload
sudo systemctl restart myapp

⏱ systemd Timers (cron replacement)

Timer example

[Timer]
OnBootSec=5min
OnUnitActiveSec=1h

Enable timer:

sudo systemctl enable backup.timer
sudo systemctl start backup.timer

🧯 Common systemd Problems

Problem	Cause
Service fails to start	Wrong path
Permission denied	Wrong User
Starts then stops	ExecStart exits
Not starting at boot	Not enabled

Debug:

journalctl -xe

🧪 Common Admin Commands

🔹 1️⃣ `systemctl reboot`

systemctl reboot

What it does

👉 Reboots (restarts) the entire system

It is the same as:

Turning the server OFF
Then turning it ON again

What happens internally

All running services are stopped safely
Files are synced to disk
Kernel restarts
System boots again

When to use

After kernel updates
System stuck or unstable
Configuration changes that need reboot

⚠️ Warning

SSH connection will be lost
On EC2 → instance restarts

🔹 2️⃣ `systemctl poweroff`

systemctl poweroff

What it does

👉 Shuts down the system completely

Think of it as:

“Turn off the server”

What happens

Services stop
System shuts down
Power is off

On AWS EC2

⚠️ Important:

Instance goes to stopped state
You must start it again manually
Public IP may change (if not elastic IP)

When to use

Maintenance
Cost saving (EC2)
Permanent shutdown

🔹 3️⃣ `systemctl daemon-reexec`

systemctl daemon-reexec

This one is special 🧠 (often confusing)

What it does

👉 Restarts systemd itself, NOT the system

Reloads the systemd binary
Keeps services running
Does NOT reboot

Why is this needed?

Used when:

systemd package is updated
systemd configuration changes
systemctl behaves strangely

What does NOT happen

❌ No reboot ❌ No shutdown ❌ No service stop

🧪 Simple Comparison Table

Command	Effect
`systemctl reboot`	Restart entire system
`systemctl poweroff`	Shutdown system
`systemctl daemon-reexec`	Restart systemd only

⚠️ Permissions

All these commands need root access:

sudo systemctl reboot

sudo systemctl poweroff

sudo systemctl daemon-reexec

🎯 Interview-Ready Q&A

Q: What is systemd?

systemd is a system and service manager used in modern Linux distributions that initializes the system and manages services.

Q: What is PID 1?

The first process started by the kernel, responsible for starting all other services.

Q: Difference between reload & restart?

Reload: re-read config
Restart: stop and start

🧾 Must-Know Commands Cheat Sheet

systemctl status
systemctl start
systemctl stop
systemctl restart
systemctl enable
systemctl disable
journalctl

🏁 Final Summary

systemd is the backbone of modern Linux service management, controlling how services start, stop, restart, log, and behave during system boot and runtime.

Environment Variables & Shell

1️⃣ What are Environment Variables?

Environment variables are: 👉 Key–value pairs used by the system and applications.

Example:

JAVA_HOME=/usr/lib/jvm/java-17
PORT=8080
DB_HOST=localhost

👉 In AWS, environment variables are used everywhere.

2️⃣ Why Environment Variables are Important in AWS?

Used for:

App configuration
Database credentials
Ports
AWS SDK settings
CI/CD pipelines

👉 Avoid hard-coding values in code.

3️⃣ Viewing Environment Variables

View all

env

printenv

View specific variable

echo $HOME
echo $PATH

4️⃣ PATH Variable (VERY IMPORTANT)

PATH tells Linux where to find commands.

Check PATH:

echo $PATH

Example output:

/usr/local/bin:/usr/bin:/bin

👉 If a command is not in PATH → “command not found”.

5️⃣ Setting Environment Variables (Temporary)

export APP_ENV=prod
export PORT=8080

Valid only:

For current session
Until terminal is closed

6️⃣ Setting Environment Variables (Permanent)

For current user

Edit:

nano ~/.bashrc

Add:

export APP_ENV=prod
export JAVA_HOME=/usr/lib/jvm/java-17

Apply changes:

source ~/.bashrc

System-wide (All users)

Edit:

sudo nano /etc/environment

Example:

APP_ENV=prod

7️⃣ Shell Configuration Files

Important shell files:

File	Purpose
`~/.bashrc`	User shell config
`~/.bash_profile`	Login shell
`/etc/profile`	System-wide
`/etc/environment`	Global variables

👉 AWS EC2 user config is usually in .bashrc.

8️⃣ Using Environment Variables in Apps

Example:

echo $DB_HOST

In shell script:

echo "Running in $APP_ENV mode"

🔟 Common AWS Problems

❌ App not picking config ✔ Check env variable ✔ Check .bashrc ✔ Restart service

1️⃣1️⃣ What you MUST remember

✅ Environment variables store config ✅ PATH controls command access ✅ export sets variables ✅ .bashrc is very important ✅ Restart shell or service to apply changes

Searching & Text Processing (Linux)

🔍 What is Searching & Text Processing?

Searching & Text Processing means:

Finding files
Searching text inside files
Filtering output
Modifying text streams
Analyzing logs & data

👉 In simple words:

It is how Linux reads, searches, filters, and transforms text efficiently

Linux treats almost everything as text (logs, configs, outputs).

🧱 Core Philosophy (VERY IMPORTANT)

Linux tools follow:

Do one thing and do it well

Then you combine tools using pipes (|)

Example:

cat log.txt | grep ERROR | sort | uniq -c

📁 Searching Files (find & locate)

🔹 `find` – Real-time search

find /var/log -name "*.log"

By size:

find / -size +100M

By modified time:

find /home -mtime -1

Delete files:

find /tmp -type f -name "*.tmp" -delete

🔹 `locate` – Fast index-based search

locate nginx.conf

Update index:

sudo updatedb

⚠️ May not find newly created files until index updates

📄 Searching Text Inside Files (`grep`)

Basic search

grep "error" app.log

Case-insensitive:

grep -i error app.log

Recursive:

grep -R "password" /etc

Line numbers:

grep -n "failed" auth.log

Invert match:

grep -v "INFO" app.log

🔁 Regular Expressions (Regex Basics)

grep "^ERROR" app.log   ## line starts with ERROR
grep "failed$" app.log  ## line ends with failed
grep "[0-9]\{3\}" file  ## 3 digits

🧪 Filtering & Transforming Text

🔹 `cut` – Column extraction

cut -d: -f1 /etc/passwd

🔹 `awk` – Powerful text processing

awk '{print $1, $3}' file.txt

Condition:

awk '$3 > 100 {print $1}' data.txt

Sum column:

awk '{sum+=$2} END {print sum}' sales.txt

🔹 `sed` – Stream editor (modify text)

Replace:

sed 's/error/ERROR/g' app.log

Edit file:

sed -i 's/8080/9090/g' server.conf

Delete lines:

sed '5d' file.txt

📊 Sorting & Counting

🔹 `sort`

sort file.txt
sort -n numbers.txt
sort -r file.txt

🔹 `uniq`

uniq file.txt
sort file.txt | uniq
sort file.txt | uniq -c

🔹 `wc` – Word count

wc file.txt
wc -l file.txt

🔗 Pipes (`|`) – Power of Linux

grep ERROR app.log | wc -l

ps aux | grep nginx

📂 File Content Viewing

Command	Use
`cat`	Show entire file
`less`	Scrollable view
`head`	First lines
`tail`	Last lines

Live logs:

tail -f app.log

🧯 Real-World Use Cases

🔥 Find errors in logs

grep -i error /var/log/syslog

🔥 Top IPs hitting server

awk '{print $1}' access.log | sort | uniq -c | sort -nr | head

🔥 Kill process using port

netstat -tulpn | grep 8080

🧠 Common Mistakes

Mistake	Fix
Using cat unnecessarily	Use grep directly
Not sorting before uniq	Always sort
Forgetting quotes	Quote patterns
Using locate for live search	Use find

🎯 Interview-Ready Questions

Q: Difference between grep & find?

grep → search text
find → search files

Q: What is a pipe?

Connects output of one command to input of another

🧾 Must-Know Commands Cheat Sheet

find
locate
grep
awk
sed
cut
sort
uniq
wc
head
tail

🏁 Final Summary

Searching & text processing tools allow Linux users to quickly find information, analyze logs, filter outputs, and automate data handling using simple yet powerful commands.

Compression & Archiving (Linux)

1️⃣ What is Archiving vs Compression?

Archiving

Combines multiple files into one
Example: .tar

Compression

Reduces file size
Example: .gz, .zip

👉 Very often used together:

.tar.gz

2️⃣ `tar` – Archiving Tool (MOST IMPORTANT)

Create archive

tar -cvf backup.tar folder/

Options:

c → create
v → verbose
f → file name

Extract archive

tar -xvf backup.tar

3️⃣ Compressed Archives (`tar.gz`)

Create compressed archive

tar -czvf backup.tar.gz folder/

Extract compressed archive

tar -xzvf backup.tar.gz

4️⃣ `gzip` & `gunzip`

Compress file

gzip file.log

Creates:

file.log.gz

Decompress

gunzip file.log.gz

5️⃣ `zip` & `unzip`

Create zip

zip -r backup.zip folder/

Extract zip

unzip backup.zip

👉 zip is useful when sharing files with Windows users.

6️⃣ Backup Basics (AWS Context)

Common backup targets:

Application files
Logs
Database dumps

Example:

tar -czvf app-backup.tar.gz /opt/app

Upload to S3:

aws s3 cp app-backup.tar.gz s3://my-bucket/

7️⃣ AWS Real-Life Example

Before EC2 termination

tar -czvf logs-backup.tar.gz /var/log

8️⃣ Common Mistakes

❌ Forgetting f option ❌ Extracting in wrong directory ❌ Overwriting files

9️⃣ What you MUST remember

✅ tar is most important ✅ .tar.gz is very common ✅ zip for cross-platform ✅ Backups are essential in AWS ✅ Always verify archive

SSH & Remote Access

🔐 What is SSH?

SSH (Secure Shell) is a protocol used to:

Connect to remote servers securely
Execute commands remotely
Transfer files safely
Manage servers over the network

👉 In simple words:

SSH lets you control another computer securely from your terminal

🌍 Why SSH is Important

Without SSH:

Passwords sent in plain text
Easy hacking

With SSH:

Encrypted communication
Secure authentication
Industry standard for server access

🧠 How SSH Works (Concept)

Client sends connection request
Server responds with public key
Client verifies server
Authentication happens (password or key)
Encrypted session starts

🖥 SSH Basic Command

ssh user@server_ip

Example:

ssh ec2-user@13.233.45.10

🔑 SSH Authentication Methods

2️⃣ Key-Based Authentication (BEST PRACTICE)

Generate key

ssh-keygen

Copy key to server

ssh-copy-id user@server_ip

Or manually:

cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

🔐 SSH Key Files

File	Purpose
`id_rsa`	Private key (never share)
`id_rsa.pub`	Public key
`authorized_keys`	Allowed keys
`known_hosts`	Trusted servers

🔒 File Permissions (VERY IMPORTANT)

chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Wrong permissions = SSH login fails ❌

🚪 SSH Port & Config

Default port: 22

Config file:

/etc/ssh/sshd_config

Common settings:

PermitRootLogin no
PasswordAuthentication no
Port 2222

Restart SSH:

sudo systemctl restart sshd

📁 File Transfer with SSH

🔹 SCP

scp file.txt user@server:/path

Download:

scp user@server:/path/file.txt .

🔹 RSYNC (Preferred)

rsync -avz file.txt user@server:/path

🔄 SSH Tunneling & Port Forwarding

Remote Command Execution

ssh user@server "df -h"

🧯 Common SSH Errors & Fixes

Error	Fix
Permission denied	Check key & permissions
Connection refused	SSH not running
Host key changed	Remove from known_hosts
Timeout	Firewall / port blocked

Fix host key:

ssh-keygen -R server_ip

☁️ SSH in AWS EC2 (Real-World)

Connect:

ssh -i mykey.pem ec2-user@ec2-ip

Permissions:

chmod 400 mykey.pem

🔐 SSH Security Best Practices

✔ Use key-based auth ✔ Disable root login ✔ Change default port ✔ Use firewall ✔ Use fail2ban

🧪 Advanced SSH Options

ssh -v user@server

ssh -i key.pem user@server

ssh -o StrictHostKeyChecking=no user@server

🔁 SSH Config File (Client Side)

~/.ssh/config

Example:

Host myserver
  HostName 13.233.45.10
  User ec2-user
  IdentityFile ~/.ssh/mykey.pem

Connect:

ssh myserver

🎯 Interview-Ready Q&A

Q: What is SSH?

SSH is a secure protocol used for remote access and command execution over encrypted connections.

Q: Password vs Key authentication?

Password → weaker
Key → stronger & secure

Q: What is known_hosts?

Stores server public keys to prevent MITM attacks

🧾 Must-Know Commands Cheat Sheet

ssh
ssh-keygen
ssh-copy-id
scp
rsync
chmod

🏁 Final Summary

SSH is the backbone of secure remote server management, enabling encrypted access, file transfers, and automation across Linux and cloud systems.

Bash Scripting Basics

🐚 What is Bash?

Bash (Bourne Again Shell) is:

A command-line shell
A scripting language
The default shell on most Linux systems

👉 In simple words:

Bash lets you automate tasks by writing commands in a file

📜 What is a Bash Script?

A Bash script is:

A text file
Contains Linux commands
Executed line by line

File extension:

.sh

Example:

backup.sh

🧱 Structure of a Bash Script

2️⃣ Commands

echo "Hello World"

▶️ Running a Bash Script

Make executable

chmod +x script.sh

Run

./script.sh

bash script.sh

📥 User Input

read -p "Enter name: " name
echo "Hello $name"

🔁 Conditional Statements

if-else

if [ $age -gt 18 ]; then
  echo "Adult"
else
  echo "Minor"
fi

Common operators:

-eq → equal
-ne → not equal
-gt → greater than
-lt → less than

🔄 Loops

for loop

for i in 1 2 3
do
  echo $i
done

while loop

while true
do
  echo "Running..."
  sleep 1
done

🧠 Functions

greet() {
  echo "Hello $1"
}

greet Dev

📁 File & Directory Checks

if [ -f file.txt ]; then
  echo "File exists"
fi

if [ -d /var/log ]; then
  echo "Directory exists"
fi

🔎 Command Line Arguments

echo "Script name: $0"
echo "First arg: $1"
echo "All args: $@"

Run:

./script.sh arg1 arg2

🔗 Pipes & Redirection

Redirect output

ls > file.txt

Append

ls >> file.txt

Redirect error

ls invalid 2> error.txt

🧪 Debugging Bash Scripts

bash -x script.sh

Inside script:

set -x

Stop on error:

set -e

🧯 Common Mistakes

Mistake	Fix
Missing shebang	Add `#!/bin/bash`
Spaces in variable	`var=value`
Forget chmod	`chmod +x`
Using wrong quotes	Use `"`

☁️ Real-World Use Case

Backup Script Example

#!/bin/bash
tar -czf backup.tar.gz /home/dev
echo "Backup completed"

🎯 Interview-Ready Questions

Q: What is Bash?

Bash is a Unix shell and scripting language used to automate system tasks.

Q: Difference between `$@` and `$*`?

$@ → separate arguments
$* → single string

Q: What is shebang?

It specifies the interpreter for the script.

🧾 Must-Know Bash Commands

echo
read
if
for
while
case
function

🏁 Final Summary

Bash scripting allows you to automate repetitive Linux tasks, manage servers efficiently, and build powerful command-line tools using simple scripts.

Linux Security Basics

1️⃣ Firewall Basics

A firewall controls: 👉 Which traffic is allowed or blocked.

Linux firewalls:

iptables (low-level)
firewalld
ufw (Ubuntu)

Check firewall status

Ubuntu:

sudo ufw status

Amazon Linux:

sudo systemctl status firewalld

👉 In AWS, Security Groups act as the main firewall, but Linux firewall still matters.

2️⃣ File Permission Security

Permissions prevent:

Unauthorized access
Accidental deletion
Data leaks

Best practices:

No 777 permissions
Use 755 for folders
Use 644 for files

Example:

chmod 600 id_rsa

3️⃣ SSH Security (VERY IMPORTANT)

Best practices:

Use key-based authentication
Disable password login
Avoid root login

SSH config file:

/etc/ssh/sshd_config

Important settings:

PermitRootLogin no
PasswordAuthentication no

Restart SSH:

sudo systemctl restart sshd

4️⃣ Running Services Securely

Never run apps as root ❌

Run as:

nginx
appuser
docker

Check service user:

ps aux | grep nginx

5️⃣ Principle of Least Privilege

Give:

Only required access
Only required permissions

Example:

App user → app folder only
Log user → logs only

Layer	Security
AWS	Security Groups, IAM
Linux	Users, permissions, firewall
App	Authentication, authorization

7️⃣ Common AWS Security Mistakes

❌ SSH open to 0.0.0.0/0 ❌ Root login enabled ❌ World-writable files ❌ Hard-coded secrets

8️⃣ AWS Real-Life Example

Secure SSH:

chmod 400 mykey.pem
sudo nano /etc/ssh/sshd_config
sudo systemctl restart sshd

9️⃣ What you MUST remember

✅ Security is layered ✅ Use key-based SSH ✅ Restrict file permissions ✅ Don’t run apps as root ✅ AWS + Linux security together

Logs & Troubleshooting (Linux)

1️⃣ What are Logs?

Logs are files that record:

System activity
Errors
Application events

👉 Logs tell you what went wrong and why.

2️⃣ System Logs

System logs show:

Boot issues
Service failures
OS-level errors

Common locations:

Log	Purpose
`/var/log/messages`	System events (Amazon Linux)
`/var/log/syslog`	System logs (Ubuntu)
`/var/log/dmesg`	Kernel messages
`/var/log/secure`	Security & SSH logs

View logs:

less /var/log/messages

3️⃣ Application Logs

Each application has its own logs.

Examples:

Nginx:

/var/log/nginx/access.log
/var/log/nginx/error.log

Docker:
```
docker logs container_id
```
Java App:
```
app.log
```

4️⃣ Reading Error Logs (MOST IMPORTANT)

View last errors

tail -n 50 error.log

Live error tracking

tail -f error.log

Search errors

grep "ERROR" error.log

6️⃣ Basic Troubleshooting Flow (VERY IMPORTANT)

When something breaks:

Step 1: Check service

systemctl status nginx

Step 2: Check logs

journalctl -u nginx

Step 3: Check port

ss -tulnp

Step 4: Test locally

curl localhost

Step 5: Check permissions

ls -l

Step 6: Check disk

df -h

7️⃣ AWS Real-Life Example

❌ Website not loading

Checklist:

Is service running?
Is port open?
Is app listening?
Are logs showing errors?
Is Security Group correct?

8️⃣ Common AWS Errors & Logs

Error	Check
403 Forbidden	File permissions
502 Bad Gateway	App crash
Connection refused	Service down
Disk full	`df -h`

9️⃣ What you MUST remember

✅ Logs explain failures ✅ Always check logs first ✅ tail -f for live issues ✅ Follow troubleshooting steps ✅ AWS issues = Linux + AWS configs

Linux for Cloud (AWS Context)

☁️ What Does “Linux for Cloud (AWS)” Mean?

It means:

Using Linux to run, manage, secure, and scale cloud resources on AWS

In AWS:

Most servers (EC2) run Linux
Most services assume Linux knowledge
Cloud automation = Linux + scripting

👉 If you know Linux well, AWS becomes easy

🧠 Why Linux Is So Important in AWS?

Reason	Explanation
EC2 runs Linux	Amazon Linux, Ubuntu, RHEL
Cost	Linux is free / cheaper
Automation	Bash, cron, systemd
Security	SSH, permissions, firewall
Performance	Lightweight & stable

🖥 Linux in AWS = EC2

EC2 = Virtual Linux Server

Popular Linux AMIs:

Amazon Linux 2 / Amazon Linux 2023
Ubuntu 20.04 / 22.04
RHEL
CentOS (legacy)

🔑 Accessing Linux EC2 (SSH)

ssh -i key.pem ec2-user@EC2_PUBLIC_IP

Permissions:

chmod 400 key.pem

Default users:

OS	User
Amazon Linux	`ec2-user`
Ubuntu	`ubuntu`
RHEL	`ec2-user`

📁 Linux Filesystem in Cloud Servers

Important directories:

Path	Use
`/`	Root
`/home/ec2-user`	User data
`/var/log`	Logs
`/etc`	Config files
`/opt`	Custom apps

Cloud admins live inside /var and /etc

📦 Package Management (Cloud Must-Know)

Amazon Linux:

sudo yum install nginx

Ubuntu:

sudo apt install nginx

Update system:

sudo yum update -y

🔧 Service Management (Production Critical)

AWS apps run as services

sudo systemctl start nginx
sudo systemctl enable nginx
sudo systemctl status nginx

Logs:

journalctl -u nginx

📊 Monitoring & Logs (Very Important in Cloud)

Check system usage:

top
htop
free -m
df -h

View logs:

tail -f /var/log/messages
tail -f /var/log/syslog

AWS CloudWatch often reads these logs.

💾 Storage in AWS (Linux View)

AWS Storage → Linux Disk

AWS	Linux
EBS Volume	`/dev/xvda`, `/dev/nvme0n1`
S3	Mounted via tools
Instance Store	Temporary disk

Check disks:

lsblk
df -h

Mount EBS:

mount /dev/xvdf /data

🔐 Linux Security in AWS

🔹 SSH Security

Key-based auth
Disable root login
Change SSH port

🔹 Permissions

chmod 600 key.pem
chown ec2-user file

🔹 Firewall

Security Groups (AWS)
iptables / firewalld (Linux)

🌐 Networking (Linux + AWS)

Check IP:

ip a

Check ports:

ss -tuln

Test connectivity:

curl localhost
ping google.com

AWS Networking concepts mapped to Linux:

AWS	Linux
Security Group	Firewall rules
ENI	Network interface
ALB	Reverse proxy

🧪 Automation with Bash (Cloud Core Skill)

Example startup script:

#!/bin/bash
yum install -y nginx
systemctl start nginx
systemctl enable nginx

Used in:

EC2 User Data
CI/CD pipelines
Auto Scaling

🔄 Scaling & Linux

In Auto Scaling:

Linux boots
User-data runs
App starts automatically

Your Linux setup must be:

Idempotent
Fast
Error-free

☁️ Linux + AWS Services Mapping

AWS Service	Linux Role
EC2	OS & apps
ECS/EKS	Containers on Linux
Lambda	Linux runtime
CloudWatch	Linux logs
CodeDeploy	Linux deployments

🧯 Common Cloud Linux Problems

Problem	Cause
SSH timeout	SG / NACL
Disk full	Logs
App stopped	systemd
Permission denied	chmod/chown
High CPU	runaway process

🎯 Interview-Ready Q&A

Q: Why Linux is preferred in AWS?

Linux is lightweight, secure, open-source, and well suited for cloud scalability and automation.

Q: How do you secure EC2?

SSH keys
Security Groups
OS hardening
Patch updates

Q: What is user-data?

A script executed at first boot to configure the Linux instance.

🧾 Must-Know Linux Commands for AWS

ssh
lsblk
df -h
top
systemctl
journalctl
curl
chmod
chown

🏁 Final Summary (Very Important)

Linux is the backbone of AWS cloud computing. Mastering Linux means you can deploy, secure, scale, and troubleshoot cloud infrastructure confidently.

🐧 Linux Basics You MUST Know Before AWS

Think of Linux commands in 8 core groups.

1️⃣ File & Directory Commands (MOST USED)

📂 `pwd`

pwd

Shows current directory

📌 Used when navigating EC2.

Option	Meaning
`-l`	long listing
`-a`	show hidden files

📄 `less` (IMPORTANT)

less file.txt

Scroll large files (logs).

Keys:

q → quit
/ → search

📂 `mkdir`

mkdir logs
mkdir -p app/data

📂 `cp`

cp file1 file2
cp -r dir1 dir2

2️⃣ File Permissions & Ownership (AWS CRITICAL)

4️⃣ Package Management (Already Covered – Quick List)

Amazon Linux

yum install
yum remove
yum update
dnf install

5️⃣ Service Management (systemd)

6️⃣ Networking Commands (AWS IMPORTANT)

🌐 `netstat` (older)

netstat -tuln

9️⃣ Search & Text Processing (Logs)

🔍 `find`

find / -name app.log

🔟 SSH & Remote Access

🔐 `ssh`

ssh -i key.pem ec2-user@IP

🔐 `scp`

scp file.txt ec2-user@IP:/home/ec2-user/

1️⃣1️⃣ Environment & Shell Basics

🌱 `env`

env

🌱 `echo`

echo $APP_ENV

1️⃣2️⃣ AWS User-Data Script Essentials

#!/bin/bash
yum update -y
yum install httpd -y
systemctl start httpd
systemctl enable httpd

📌 Requires:

chmod +x
Correct commands

📝 Nano Editor (Beginner Friendly)

What is Nano?

Nano is a terminal-based text editor in Linux.

📌 Think of Nano like:

Notepad, but inside the terminal
Very easy compared to vi / vim

How to open Nano

Open a file (or create if not exists)

nano file.txt

If file.txt exists → it opens
If not → Nano creates it

Nano screen layout

When Nano opens, you’ll see:

Top → File name
Middle → Text area (where you type)
Bottom → Shortcut keys

Example at bottom:

^G Get Help   ^O Write Out   ^X Exit

👉 ^ means CTRL

So:

^X = CTRL + X
^O = CTRL + O

MOST IMPORTANT Nano commands ⭐

1️⃣ Save file

CTRL + O

Write Out (save)
Press Enter to confirm file name

2️⃣ Exit Nano

CTRL + X

If file is not saved:

Nano will ask → Save? (Y/N)

3️⃣ Cut a line

CTRL + K

Cuts (removes) the current line
Works like cut, not copy

6️⃣ Replace text

CTRL + \

Search and replace

Command	Action
Arrow keys	Move cursor
`CTRL + A`	Start of line
`CTRL + E`	End of line
`CTRL + Y`	Page up
`CTRL + V`	Page down

Selecting text (Mark mode)

Start selection

CTRL + ^

(or CTRL + SHIFT + 6)

Move cursor to select text

Cut selected text

CTRL + K

Undo / Redo

Action	Command
Undo	`ALT + U`
Redo	`ALT + E`

Show line numbers (very useful)

Inside Nano:

ALT + N

Or open with line numbers:

nano -l file.txt

Real-world usage examples (VERY COMMON)

Edit config file

nano /etc/nginx/nginx.conf

Edit app config

nano application.properties

Why Nano is beginner-friendly ❤️

✔ No modes (unlike vim) ✔ Commands always visible ✔ Easy save & exit ✔ Simple shortcuts

Quick cheat sheet 📌

Task	Command
Open file	`nano file.txt`
Save	`CTRL + O`
Exit	`CTRL + X`
Cut line	`CTRL + K`
Paste	`CTRL + U`
Search	`CTRL + W`
Replace	`CTRL + \`
Help	`CTRL + G`

📝 VI Editor (Powerful but Confusing at First)

What is `vi`?

vi is a terminal-based text editor in Linux/Unix systems.

Old
Extremely powerful
Available on almost every Linux server
Default editor on many servers (EC2, production machines)

📌 Important:

Even if Nano is easier, you MUST know vi Because sometimes Nano is not installed, but vi always is.

Why `vi` feels difficult for beginners 😵

Because vi has MODES.

Nano → type directly Vi → depends on which mode you are in

👉 This is the most important concept.

🔁 VI MODES (MOST IMPORTANT PART)

vi works in three main modes:

Mode	Purpose
Normal mode	Navigation + commands
Insert mode	Typing text
Command mode	Save, quit, search

When you open vi, you are NOT in typing mode.

You start in Normal mode ❗

1️⃣ Normal Mode (Default mode)

This is the command mode for movement and actions.

You cannot type text
Every key is treated as a command

Examples:

dd → delete line
yy → copy line
p → paste
gg → go to top

📌 If something weird happens → You are probably in Normal mode 😄

Key	Meaning
`i`	Insert before cursor
`a`	Append after cursor
`o`	New line below
`O`	New line above

3️⃣ Command Mode (Colon `:` mode)

Used for:

Save
Quit
Search
Replace
Line numbers

You enter command mode by typing:

(while in Normal mode)

Example:

:w
:q
:wq

🚀 Opening a file in vi

vi file.txt

If file doesn’t exist:

It will be created when you save

✍️ BASIC WORKFLOW (VERY IMPORTANT)

This is how 90% of people use vi:

Open file
Press i
Type text
Press ESC
Save and quit

Let’s see commands.

💾 Save and Exit Commands (MUST KNOW)

Command	Meaning
`:w`	Save (write)
`:q`	Quit
`:wq`	Save and quit
`:x`	Save and quit
`:q!`	Quit without saving (force)
`:w!`	Force save

📌 Examples:

Save only:

:w

Save and exit:

:wq

Exit without saving:

:q!

You can use arrow keys, BUT real vi users use:

Key	Action
`h`	Left
`l`	Right
`j`	Down
`k`	Up

Why?

Faster
Hands stay on keyboard

Line & file movement

Command	Meaning
`0`	Start of line
`$`	End of line
`gg`	Go to top
`G`	Go to bottom
`:10`	Go to line 10

✂️ DELETE, COPY, PASTE (VERY IMPORTANT)

Copy (Yank)

Command	Action
`yy`	Copy current line
`yw`	Copy word
`y$`	Copy till end

Paste

Command	Action
`p`	Paste below cursor
`P`	Paste above cursor

🔁 Undo and Redo

Action	Command
Undo	`u`
Redo	`CTRL + R`

📌 Undo is life saver.

🔍 SEARCHING (Very useful)

Search forward

/word

Search backward

?word

Press:

n → next match
N → previous match

🔄 SEARCH & REPLACE (POWER FEATURE)

Format:

:s/old/new/

Examples:

Replace first match in line:

:s/java/spring/

Replace all in line:

:s/java/spring/g

Replace in entire file:

:%s/java/spring/g

Replace with confirmation:

:%s/java/spring/gc

🔢 Line Numbers (VERY IMPORTANT IN DEBUGGING)

Show line numbers:

:set number

Hide line numbers:

:set nonumber

Shortcut:

:set nu

📌 VISUAL MODE (Text selection)

Enter Visual mode:

Move cursor to select text

Commands after selection:

d → delete
y → copy

Visual line mode:

⚙️ REAL PRODUCTION USAGE EXAMPLES

Edit config file on EC2

vi /etc/nginx/nginx.conf

Edit environment variables

vi ~/.bashrc

Edit application properties

vi application.properties

⚠️ COMMON BEGINNER MISTAKES

❌ Typing without entering Insert mode ❌ Forgetting to press ESC ❌ Not knowing how to quit ❌ Panic when screen freezes

✅ Solution:

ESC
:q!

Always works 😄

🧠 MENTAL MODEL (IMPORTANT)

Think like this:

Normal mode → THINK
Insert mode → TYPE
Command mode → CONTROL

🆚 VI vs NANO (Quick Comparison)

Feature	Nano	Vi
Beginner friendly	✅	❌
Always installed	❌	✅
Powerful editing	❌	✅
Used in production	Rare	Very common

🧾 MUST-MEMORIZE COMMANDS (Cheat Sheet)

i        → insert
ESC      → normal mode
:w       → save
:q       → quit
:wq      → save & quit
:q!      → quit force
dd       → delete line
yy       → copy line
p        → paste
u        → undo
/word    → search
:set nu  → line numbers

Final Advice ❤️

Don’t try to memorize everything at once.

Start with:

i
ESC
:wq
dd
/search

That’s enough for real-world server work.

🔑 Big Picture: EC2 Access + Linux Users (ONE CLEAR MODEL)

When you create an EC2 instance, there are two separate systems involved:

1️⃣ AWS level (IAM & Key Pair)

Controls:

Who can connect to the EC2
Uses SSH keys (.pem)

2️⃣ Linux level (Users & Groups)

Controls:

What a person can do inside the server
Uses users, groups, permissions

👉 These two are independent but work together.

🔐 What the `.pem` file really does

A .pem file is NOT a user
It is NOT root access
It only proves:

“I am allowed to connect to this server”

When you SSH using a PEM file:

ssh -i key.pem ec2-user@IP

You log in as:

ec2-user

✔ Not root ✔ Normal Linux user ✔ Has sudo access

❌ No

AWS disables direct root login for security. When you log in, you are a normal user Root access is temporary and controlled.

👥 Giving EC2 access to another person (CORRECT WAY)

You do NOT share your PEM file.

Correct process:

Other person generates their own SSH key
They send you only the public key
You create a Linux user on EC2
You add their public key to that user
You set permissions for what they can access

Why AWS does NOT log you in as root

AWS disables direct root login by default.

Reasons:

Security
- Root can delete OS, disks, users
Accidental damage
- One wrong command can destroy server
Industry best practice
- Least privilege principle

So AWS says:

“Login as a normal user, become root only when needed.”

🔐 Then how can `ec2-user` do admin work?

Because ec2-user has sudo access.

Check:

groups ec2-user

Output:

ec2-user wheel

The wheel group allows:

sudo

🚀 How to access root (IMPORTANT)

There are two correct and safe ways.

✅ Method 1: Run a single command as root

sudo command

Example:

sudo yum install nginx

What happens:

Only this command runs as root
You remain ec2-user

Check:

sudo whoami

Output:

root

✅ Method 2: Switch to full root shell

sudo su -

sudo -i

Now your prompt changes:

[root@ip-172-31-x-x ~]#

Now:

You are root
You have full control

To exit root:

exit

⚠️ Mental model (VERY IMPORTANT)

Think like this:

PEM file → proves who you are
Linux user → decides what you can do
sudo → temporary root power

PEM file ≠ root

📌 One-command summary

Action	Result
SSH with PEM	Login as normal user
`whoami`	ec2-user
`sudo command`	Run as root
`sudo su -`	Become root
Root SSH login	Disabled

✅ Final clear statement (remember this)

When you log in using a PEM file, you are logged in as a normal Linux user (like ec2-user), not as root. AWS disables direct root login for security reasons. To perform administrative tasks, you temporarily become root using sudo.

How to create a new user and how to do proper setup for that user

This is exactly how it is done on real EC2 servers.

👤 Step 2: Create a new Linux user

Create a new user (example: devuser):

sudo useradd devuser

What this does:

Creates a Linux user named devuser
Assigns a UID (user ID)
Creates entry in /etc/passwd

When you create a user with useradd, no password is set.

Set password:

sudo passwd devuser

Enter a new password → done ✅

To list all users in Linux, use:

cat /etc/passwd

If you want only usernames (clean list):

cut -d: -f1 /etc/passwd

To see currently logged-in users:

who

To switch to another user in Linux:

su - username

OR no password needed, using sudo (recommended):

sudo su - username

To go back to your previous user:

exit

📂 Step 3: Create home directory (IMPORTANT)

Some systems create it automatically, but to be safe:

sudo mkdir /home/devuser

Set ownership:

sudo chown devuser:devuser /home/devuser

Now:

/home/devuser

belongs only to devuser.

🔐 Step 4: Create `.ssh` directory

This is required for SSH key login.

sudo mkdir /home/devuser/.ssh

Set correct permissions:

sudo chmod 700 /home/devuser/.ssh
sudo chown devuser:devuser /home/devuser/.ssh

Why 700?

Only the user can read/write/enter
SSH will refuse login if permissions are wrong

🔑 Step 5: Add public key (MOST IMPORTANT)

Create the authorized keys file:

sudo nano /home/devuser/.ssh/authorized_keys

Paste the public key of the user here.

⚠️ Only public key, never private key.

Set permissions:

sudo chmod 600 /home/devuser/.ssh/authorized_keys
sudo chown devuser:devuser /home/devuser/.ssh/authorized_keys

Now the user can log in from their own machine:

ssh -i devuser.pem devuser@EC2-IP

Check:

whoami

Output:

devuser

✅ User is logged in ✅ Not root ✅ Isolated from other users

🔐 Step 7: Decide sudo access (VERY IMPORTANT)

❓ Should the user be root-capable?

❌ If NO (most secure):

Do nothing.

User:

Cannot install software
Cannot change system config
Cannot access /etc, /var, etc.

✅ If YES (admin / senior dev):

Add user to sudo group.

On Amazon Linux:

sudo usermod -aG wheel devuser

On Ubuntu:

sudo usermod -aG sudo devuser

Now user can run:

sudo command

📂 Step 8: Folder & file access control

Example: You have a folder:

/app-data

You want:

devuser → access
Others → no access

sudo chown devuser:devuser /app-data
sudo chmod 700 /app-data

Now:

Only devuser can access
Others are blocked

👥 Step 9: Groups (Professional setup)

Create a group:

sudo groupadd devteam

Add user to group:

sudo usermod -aG devteam devuser

Assign folder to group:

sudo chown :devteam /shared-data
sudo chmod 770 /shared-data

Now:

All devteam members can access
Others cannot

❌ Common mistakes (IMPORTANT)

❌ Forgetting .ssh permissions ❌ Putting private key on server ❌ Logging everyone in as ec2-user ❌ Giving sudo to everyone

🧠 Mental model (REMEMBER THIS)

User = identity
Group = role
SSH key = login method
Permissions = access control

✅ Final summary (Task 2)

To set up a new user on an EC2 instance, you create a Linux user, create a home directory, configure SSH access using the user’s public key, set strict permissions on .ssh files, and optionally grant sudo access using groups. This ensures secure, controlled access for each individual user.

How the other user creates their PEM file and shares it with you

This task is about what the OTHER PERSON does, not you.

🧠 First, clear one very important misunderstanding

👉 The admin does NOT create the PEM file for the user. 👉 The user creates their OWN PEM file on their OWN machine.

This is how it works in real companies.

👤 Who is “the other user”?

Developer
Teammate
Intern
Ops engineer

They want access to your EC2 server.

🔑 Step 1: User creates SSH key pair on their own machine

On their laptop / system, they run:

ssh-keygen

They will see something like:

Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa):

They can press Enter OR give a custom name:

devuser.pem

What files are created?

Two files are created:

File	Purpose
`devuser.pem`	PRIVATE KEY (never shared)
`devuser.pem.pub`	PUBLIC KEY (shared with admin)

📌 The .pem file stays ONLY with the user.

🔐 Step 2: Optional – set passphrase (recommended)

User may be asked:

Enter passphrase (empty for no passphrase):

Passphrase = extra password protection
If someone steals the key → still cannot use it

In companies: ✔️ Passphrase is recommended

📤 Step 3: User shares ONLY the public key

The user sends ONLY this file (or its content):

devuser.pem.pub

Example content:

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC7...

⚠️ They NEVER share:

devuser.pem

🔒 Why private key is never shared

If someone has the private key:

They can login as that user
No password needed
Full access

So:

Private key = identity

🖥️ Step 4: How the user logs in

From their machine, the user runs:

ssh -i devuser.pem devuser@EC2-IP

Important points:

Command runs on their laptop
Uses their private key
Logs in as devuser

🔍 Step 5: How SSH verifies identity (Simple explanation)

Server sends a challenge
User signs it with private key
Server checks public key
Match found ✔️
Login allowed 🎉

The private key is never sent to the server.

❌ Common beginner mistakes (VERY IMPORTANT)

❌ Admin generates key and shares PEM ❌ User sends private key via WhatsApp 😬 ❌ Storing private keys on server ❌ One key used by multiple users

🧠 Simple analogy (remember this)

Real world	SSH
House key	Private key (.pem)
Lock design	Public key (.pub)
House owner	EC2 admin

✅ Final summary (Task 3)

The other user generates their own SSH key pair on their own system using ssh-keygen. They keep the private key (.pem) securely with them and share only the public key (.pub) with the EC2 admin. The admin adds this public key to the user’s authorized_keys file, allowing secure SSH access without sharing secrets.

🗑️ How to Safely Delete a User in Linux

When you need to delete a user from your Linux server, follow these steps to ensure it's done safely and completely.

whoami

Make sure this is not the user you’re deleting.

2️⃣ Check if the user is currently logged in (recommended)

who

ps -u username

If they’re logged in, you can kill their session:

sudo pkill -u username

3️⃣ Delete the user account

🔹 Delete user and their home directory (recommended)

sudo userdel -r username

✔ Removes:

User account
Home directory (/home/username)
.ssh/authorized_keys (SSH access)
-r stands for remove the user’s files.

🔹 Delete user without removing home directory

sudo userdel username

(Not recommended unless you want to keep files)

4️⃣ (Important) Remove from sudo group if added earlier

If you added the user to sudo:

sudo deluser username sudo

sudo gpasswd -d username sudo

5️⃣ Verify user is deleted

id username

You should see:

id: ‘username’: no such user

6️⃣ Double-check SSH access is gone

ls /home/username

You should get:

No such file or directory

⚠️ Extra Security Check (Very Important on EC2)

If this was an AWS EC2 server, also check:

🔹 `authorized_keys` manually (just in case)

sudo find /home -name authorized_keys

🔍 What this command does (in simple words)

👉 It searches for all SSH public key files named authorized_keys
👉 inside /home directory
👉 for every user
👉 using admin (sudo) permission

🔹 `/etc/ssh/sshd_config`

Make sure no forced user is configured:

AllowUsers
AllowGroups

Restart SSH if you changed anything:

sudo systemctl restart sshd

Linux has three types of users:

🔹 1. System users

Created automatically by Linux during OS installation.

Examples from your list:

root
bin
daemon
adm
mail
sshd
systemd-network
chrony
apache

✅ These users:

Are used by the OS and services
Cannot log in
Usually have /sbin/nologin as their shell

Example:

sshd:x:74:74:Privilege-separated SSH:/usr/share/empty.sshd:/sbin/nologin

➡ SSH service runs as sshd user ➡ No human login allowed

🔹 2. Service / Application users

Created when software is installed.

Examples:

apache
dbus
rpc
tcpdump
ec2-instance-connect

Why they exist:

For security
Each service runs with limited permissions

Example:

apache:x:48:48:Apache:/usr/share/httpd:/sbin/nologin

➡ Apache web server runs as apache user

🔹 3. Normal (human) users 👤

These are real login users.

From your system:

ec2-user
devuser

✔ These users:

Have /bin/bash
Have home directories
Can log in

Example:

devuser:x:1002:1002::/home/devuser:/bin/bash

2️⃣ You created only these users 👇

You said:

i create only two user devuser, rijuldev

That is correct ✅

These are the users you created:

rijuldev
devuser

Additionally:

ec2-user

➡ Created automatically by AWS EC2

🔍 `who` means:

"Show users currently logged in"

Right now:

Only you are connected
Probably via one SSH session
No other users are logged in

So who output is empty or minimal 👉 This is normal

Try this:

whoami

You’ll see:

ec2-user

5️⃣ Summary (easy to remember 🧠)

Type	Example	Can login?
System user	`sshd`, `systemd-*`	❌ No
Service user	`apache`, `dbus`	❌ No
Human user	`devuser`, `rijuldev`, `ec2-user`	✅ Yes

🔹 What is `curl`?

curl stands for Client URL.

It is a command-line tool used to send requests to URLs and get responses from servers.

👉 In simple words:

curl is used to talk to servers from the terminal

You can:

Call APIs (REST APIs)
Download files
Upload files
Send GET, POST, PUT, DELETE requests
Send headers, tokens, cookies
Test backend APIs (Django, Spring Boot, Node, etc.)

🔹 Where is `curl` used?

Backend developers (API testing)
DevOps (health checks, automation)
Cloud engineers (AWS, servers)
CI/CD pipelines
Debugging production APIs

🔹 Is curl installed by default?

OS	Status
Linux	✅ Yes
macOS	✅ Yes
Windows 10+	✅ Yes (new versions)

Check:

curl --version

🔹 Basic curl syntax

curl [options] URL

Example:

curl https://example.com

👉 This sends a GET request to the server.

🔹 HTTP Methods in curl

Method	Purpose
GET	Fetch data
POST	Create data
PUT	Update full data
PATCH	Update partial data
DELETE	Remove data

🔹 GET Request (Most common)

curl https://api.example.com/users

With query params:

curl "https://api.example.com/users?id=10"

🔹 Show full response (headers + body)

curl -i https://example.com

🔹 Show only headers

curl -I https://example.com

🔹 Pretty print JSON response

curl https://api.example.com/users | jq

(jq is a JSON formatter tool)

🔹 POST Request (Send data)

Send JSON data

curl -X POST https://api.example.com/users \
-H "Content-Type: application/json" \
-d '{"name":"Dev","age":22}'

Explanation:

-X POST → HTTP method
-H → Header
-d → Data (body)

🔹 PUT Request (Update)

curl -X PUT https://api.example.com/users/1 \
-H "Content-Type: application/json" \
-d '{"name":"Dev","age":23}'

🔹 PATCH Request (Partial update)

curl -X PATCH https://api.example.com/users/1 \
-H "Content-Type: application/json" \
-d '{"age":24}'

🔹 DELETE Request

curl -X DELETE https://api.example.com/users/1

🔹 Sending Headers (Auth tokens, etc.)

curl https://api.example.com/profile \
-H "Authorization: Bearer YOUR_TOKEN"

Multiple headers:

curl https://api.example.com \
-H "Accept: application/json" \
-H "User-Agent: curl-test"

🔹 Authentication with curl

Basic Auth

curl -u username:password https://api.example.com

Bearer Token

curl -H "Authorization: Bearer TOKEN" https://api.example.com

🔹 Upload file using curl

curl -X POST https://api.example.com/upload \
-F "file=@image.png"

🔹 Download file using curl

curl -O https://example.com/file.zip

Rename file:

curl -o myfile.zip https://example.com/file.zip

🔹 Follow redirects

curl -L https://short.url

🔹 Save response to file

curl https://api.example.com/data -o data.json

🔹 Timeout in curl

curl --max-time 10 https://example.com

🔹 Silent mode (no progress)

curl -s https://example.com

🔹 Verbose / Debug mode (VERY IMPORTANT)

curl -v https://example.com

👉 Shows:

DNS lookup
TLS handshake
Request headers
Response headers

🔹 Common curl options (Must know)

Option	Meaning
`-X`	HTTP method
`-H`	Header
`-d`	Data
`-i`	Include headers
`-I`	Only headers
`-v`	Verbose
`-s`	Silent
`-o`	Output file
`-O`	Save with original name
`-L`	Follow redirects
`-u`	Authentication

🔹 curl vs Postman

curl	Postman
CLI based	GUI based
Lightweight	Heavy
Used in servers	Used in local testing
Automatable	Manual

👉 In real projects, both are used

🔹 curl in Backend Development (Your case)

Since you work with Django APIs & Angular, curl is useful for:

Testing API endpoints without frontend
Checking auth headers
Debugging POST/GET issues
Server health checks on EC2

Example for Django:

curl http://127.0.0.1:8000/api/expenses/

🔹 Common curl mistakes ❌

Forgetting quotes around JSON
Missing Content-Type
Wrong HTTP method
Sending GET with -d
Forgetting -L for redirects

🔹 Interview-ready answer

Q: What is curl?

curl is a command-line tool used to transfer data between a client and a server using protocols like HTTP, HTTPS, FTP, etc. It is commonly used for testing APIs, downloading/uploading files, and debugging network requests.

🔹 When should you use curl?

When you don’t have frontend
When debugging APIs on server
When automating API calls
When Postman is not available

Batch Scripting (Windows CMD) – Complete Guide

This guide covers everything you need to know about Batch scripting, from absolute basics to advanced concepts. It is structured step‑by‑step so you can learn, practice, and apply it in real projects.

1️⃣ What is Batch Scripting?

Batch scripting is a way to automate tasks in Windows using .bat or .cmd files.

Why Batch Scripts are used

Automate repetitive tasks
System administration
File & folder management
Application startup automation
Basic DevOps & CI tasks (Windows servers)

Batch File Extensions

.bat – Traditional batch file
.cmd – Modern version (recommended)

2️⃣ Creating & Running a Batch File

Create a batch file

Open Notepad
Write commands
Save as script.bat

Run a batch file

Double‑click
Run from Command Prompt

3️⃣ Basic Commands

Command	Purpose
`echo`	Print text
`@echo off`	Hide command execution
`pause`	Wait for user input
`cls`	Clear screen
`exit`	Exit script
`rem`	Comment

4️⃣ Variables in Batch

Define a variable

set name=Dev

Access variable

%name%

Enable delayed expansion

setlocal enabledelayedexpansion
!variable!

Environment variables

%USERNAME%
%OS%
%DATE%

5️⃣ User Input

set /p name=Enter your name:

6️⃣ Conditional Statements (IF)

Basic IF

if %a%==10 echo Equal

IF ELSE

if %a%==10 (
  echo Yes
) else (
  echo No
)

IF EXIST

if exist file.txt echo Found

Comparison Operators

EQU – Equal
NEQ – Not equal
GTR – Greater than
LSS – Less than

7️⃣ Loops in Batch

FOR loop (files)

for %%f in (*.txt) do echo %%f

FOR loop (numbers)

for /L %%i in (1,1,5) do echo %%i

FOR /F (command output)

for /f "tokens=1" %%a in ('date /t') do echo %%a

8️⃣ GOTO & Labels

:START
echo Hello
goto END
:END
echo Done

⚠ Avoid excessive goto – makes scripts messy

9️⃣ Functions (CALL)

call :myFunc
exit /b

:myFunc
echo Function called
exit /b

🔟 Error Handling

ERRORLEVEL

command
if %errorlevel% neq 0 echo Error occurred

Exit codes

exit /b 1

1️⃣1️⃣ File & Folder Operations

Command	Purpose
`dir`	List files
`copy`	Copy files
`move`	Move files
`del`	Delete files
`mkdir`	Create folder
`rmdir`	Delete folder
`xcopy`	Advanced copy
`robocopy`	Reliable copy

1️⃣2️⃣ Working with Paths

%~dp0   → Script directory
%~nx0   → Script name

1️⃣3️⃣ Command Line Arguments

script.bat arg1 arg2

%1 %2 %3

1️⃣4️⃣ Date & Time Handling

%DATE%
%TIME%

Custom format using FOR loop

1️⃣5️⃣ String Operations

Substring

%var:~0,4%

Replace

%var:old=new%

1️⃣6️⃣ Arithmetic Operations

set /a sum=5+3

Supported:

- − * / %

1️⃣7️⃣ Delayed Expansion (Important)

Used inside loops

setlocal enabledelayedexpansion

1️⃣8️⃣ Logging Output

script.bat > output.log
script.bat >> output.log

1️⃣9️⃣ Calling Other Scripts

call another.bat

2️⃣0️⃣ Scheduled Tasks

Run batch files using:

Task Scheduler
Startup folder

2️⃣1️⃣ Registry Operations

reg add
reg delete
reg query

⚠ Use carefully

2️⃣2️⃣ Networking Commands

Command	Use
`ping`	Connectivity
`ipconfig`	IP info
`net use`	Network drives
`netstat`	Network stats

2️⃣3️⃣ System Commands

Command	Purpose
`tasklist`	Running processes
`taskkill`	Kill process
`shutdown`	Shutdown/restart
`systeminfo`	System details

2️⃣4️⃣ Best Practices

Always use @echo off
Use comments
Validate inputs
Handle errors
Avoid hard‑coded paths
Use functions

2️⃣5️⃣ Real‑World Use Cases

Backup scripts
Log cleanup
App startup automation
Build pipelines (Windows)
Server maintenance

2️⃣6️⃣ Batch vs PowerShell

Batch	PowerShell
Old	Modern
Limited	Powerful
Simple	Advanced

Batch is still useful for legacy systems & simple automation.